kimo

kimo

Um editor de vídeo que uma IA pode dirigir.
MCP em primeiro lugar. Cada recurso é uma chamada de ferramenta. Escrito em Rust, roda em uma máquina de 2 GB.
getkimo.tech

---

O que é

v1.0.0. 255 ferramentas, testadas com fuzzing (9359 chamadas, 0 falhas). main é a v1 estável; novos trabalhos vão para branches de recursos.

kimo é um editor de vídeo sem interface gráfica. Você fala com ele pelo Model Context Protocol. Cortar, animar quadros-chave, corrigir cor, rastrear, aplicar keying, reiluminar, simular, legendar, mixar e exportar são todos comandos registrados, e a lista de ferramentas do servidor MCP é gerada a partir desse mesmo registro. Não há nenhum recurso acessível a um humano que uma IA não possa usar.

O alvo é a superfície do CapCut, After Effects, Premiere e DaVinci Resolve em um único motor: edição, motion graphics, VFX, rastreamento e cor profissional. É um motor inicial com níveis honestos. Leia FEATURES.md para saber o que é sólido, o que está em beta e o que ainda não foi construído.

• MCP em primeiro lugar. Adicione uma ferramenta no registro e ela estará no servidor MCP, no teste de fuzzing e no schema automaticamente.
• CPU, pouca memória. O renderizador é apenas CPU e otimizado para uma máquina de 2 GB. O código de GPU fica desativado por padrão, com fallback para CPU.
• Medido, não apenas afirmado. Cada linha "melhor que X" no FEATURES.md tem uma base declarada e um número medido, incluindo os casos em que perdemos.
• Poucos pontos de entrada. tools/list retorna 16 ferramentas agrupadas (15,7 KB) em vez de 255 (176 KB), medido 11,2x menor (JSON compacto, v1.0.0). Cada ferramenta individual ainda pode ser chamada pelo próprio nome.
• Testado com fuzzing. 255 ferramentas, 9359 chamadas, 0 falhas, antes de qualquer publicação.

Instalação

Baixe um binário (Linux x86_64, estático, sem dependências exceto ffmpeg):

O Windows x64 também inclui um instalador por usuário e um ZIP portátil, com o mesmo servidor MCP e fontes incluídas. Baixe os recursos do Windows em GitHub Releases, ou de um artefato de execução manual do release. Veja o guia de configuração do Windows para instalação do FFmpeg e configuração do MCP. Para compilar localmente, execute powershell -ExecutionPolicy Bypass -File packaging/windows/build.ps1 com Rust, Python 3 e Inno Setup 6 instalados.

curl -LO https://github.com/naman-sharma12345/kimo/releases/download/v1.0.0/kimo-v1.0.0-linux-x86_64.tar.gz
tar xzf kimo-v1.0.0-linux-x86_64.tar.gz
./kimo-v1.0.0-linux-x86_64/kimo-mcp        # speaks MCP over stdin/stdout

O binário tem cerca de 10 MB e responde à primeira solicitação MCP em cerca de 2 ms (medido: initialize 2 ms, primeira tools/list 6 ms). Ele é vinculado estaticamente (musl), então roda em qualquer Linux x86_64. Ele precisa de ffmpeg e ffprobe no PATH para decodificar e codificar.

Windows x64: baixe o instalador (kimo-1.0.0-windows-x86_64-setup.exe) ou o ZIP portátil do lançamento para Windows. O instalador não é assinado, então o Windows pode mostrar um aviso do SmartScreen; verifique o arquivo .sha256 ao lado dele. Veja o guia de configuração do Windows.

Binários para macOS ainda não são distribuídos; compile a partir do código-fonte lá (abaixo).

Compile a partir do código-fonte (Rust estável):

cargo build --release                 # target/release/kimo-mcp
python3 examples/demo_grade.py        # graded 2-clip sequence with a transition, built only with MCP calls
python3 examples/effects_gallery.py   # renders every effect

Configuração: adicione kimo ao seu cliente de IA

kimo é um servidor MCP local que fala via stdin/stdout (o transporte "stdio"). Não há nada para iniciar manualmente: seu cliente inicia o kimo-mcp sozinho. Você só precisa do caminho para o binário.

1. Obtenha o binário (veja Instalação acima) e coloque-o em um local estável, por exemplo:

mkdir -p ~/.local/bin && cp kimo-v1.0.0-linux-x86_64/kimo-mcp ~/.local/bin/
echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}' | ~/.local/bin/kimo-mcp

O segundo comando deve imprimir uma resposta JSON contendo "serverInfo":{"name":"kimo". Instale também ffmpeg e ffprobe (sudo apt install ffmpeg, ou seu gerenciador de pacotes).

2. Adicione-o ao seu cliente. Substitua /home/you/.local/bin/kimo-mcp pelo seu caminho absoluto. Os formatos de configuração abaixo foram verificados na documentação pública de cada cliente em 2026-10-11; as configurações dos clientes mudam, então se um falhar, verifique a página vinculada.

Claude Code

(docs)

claude mcp add --transport stdio kimo -- /home/you/.local/bin/kimo-mcp

Adicione --scope user para disponibilizá-lo em todos os projetos, ou --scope project para gravá-lo em um .mcp.json compartilhado. Verifique com claude mcp list, ou digite /mcp dentro do Claude Code. O mesmo como um arquivo .mcp.json no seu projeto:

{ "mcpServers": { "kimo": { "command": "/home/you/.local/bin/kimo-mcp", "args": [] } } }

OpenAI Codex (CLI e extensão de IDE)

(docs)

codex mcp add kimo -- /home/you/.local/bin/kimo-mcp

Ou edite ~/.codex/config.toml (ou .codex/config.toml em um projeto confiável):

[mcp_servers.kimo]
command = "/home/you/.local/bin/kimo-mcp"

Cursor

(docs)

Crie ~/.cursor/mcp.json (todos os projetos) ou .cursor/mcp.json (um projeto):

{ "mcpServers": { "kimo": { "command": "/home/you/.local/bin/kimo-mcp", "args": [] } } }

Depois abra as configurações de MCP do Cursor e ative o servidor kimo.

OpenCode

(docs)

Coloque isto em opencode.json no seu projeto, ou em ~/.config/opencode/opencode.json para todos os projetos. Observe que o OpenCode aceita command como uma lista e usa type: "local":

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "kimo": { "type": "local", "command": ["/home/you/.local/bin/kimo-mcp"], "enabled": true }
  }
}

Qualquer outro cliente MCP

kimo é um servidor MCP stdio padrão (protocolo 2024-11-05, initialize, tools/list, tools/call). Qualquer cliente que possa registrar um servidor stdio por comando funciona: dê a ele o caminho absoluto para kimo-mcp e nenhum argumento. Muitos clientes usam o formato JSON mcpServers mostrado para o Cursor; alguns (por exemplo, Zed) usam uma chave diferente, então verifique a documentação de MCP do seu cliente para o arquivo e formato exatos. Apenas os quatro clientes acima foram verificados em suas documentações.

Windows: use o caminho para kimo-mcp.exe (o instalador o coloca em %LOCALAPPDATA%\\Programs\\kimo\\bin; em JSON, escreva as barras invertidas duplicadas, veja o guia do Windows). As configurações acima são as mesmas, exceto pelo caminho; os formatos do Claude Code, Codex, Cursor e OpenCode foram verificados em suas documentações, não testados no Windows aqui. macOS: compile a partir do código-fonte (abaixo) e use o caminho para target/release/kimo-mcp.

3. Experimente. Peça ao seu assistente: "Use o kimo para importar /path/to/clip.mp4, adicionar um título e renderizar um quadro." Ou use você mesmo com o cliente Python em examples/mcp_client.py.

Lista de ferramentas agrupada ou plana

Por padrão, o servidor lista 16 ferramentas agrupadas (cerca de 15,7 KB) para não inundar janelas de contexto pequenas; chame um grupo com action e args, ou use kimo_search para encontrar uma ferramenta por intenção e kimo_describe para ver seus argumentos. Cada uma das 255 ferramentas ainda pode ser chamada pelo próprio nome. Para listar todas as 255 individualmente, defina KIMO_TOOLS=flat no ambiente do servidor:

claude mcp add --transport stdio --env KIMO_TOOLS=flat kimo -- /home/you/.local/bin/kimo-mcp

[mcp_servers.kimo.env]
KIMO_TOOLS = "flat"

Para configurações JSON, adicione "env": { "KIMO_TOOLS": "flat" } à entrada do servidor (OpenCode: "environment": { "KIMO_TOOLS": "flat" }).

Solução de problemas

• O servidor aparece como falho: execute a linha initialize acima manualmente; se funcionar, o caminho na sua configuração está errado (use um caminho absoluto).
• Ferramentas que leem ou gravam vídeo falham: ffmpeg e ffprobe não estão no PATH com o qual seu cliente é iniciado.
• Uma exportação longa expira no seu cliente: aumente o tempo limite da ferramenta MCP do cliente; KIMO_TIMEOUT_S define o limite do lado do servidor por chamada de ferramenta.

Trabalhos feitos com kimo

Estes são renders do motor, dirigidos por chamadas de ferramenta. Alguns são do filme que estamos construindo nele. Onde algo ainda está bruto, isso é dito.

Vidro fraturado

Cacos de vidro com movimento físico, refração, desfoque de movimento com correção de obturador e um núcleo amortecido para que a quebra comece no ponto de impacto. Mostrado em uma placa de cidade, linha superior antes do amortecimento do núcleo, linha inferior depois. O buraco escuro onde o vidro quebra agora pode ser preenchido com hole_fill (desativado por padrão): uma cópia desfocada e escurecida do painel (profundidade atrás do vidro), ou com hole_source=1 as camadas abaixo. O preenchimento é um desfoque, não uma cena reconstruída, então ele se lê apenas como profundidade fora de foco.

À esquerda, buraco padrão. À direita, hole_fill=1 (mesmo quadro, placa de cidade 1280x720, t=1,0 s):

Vidro fosco (efeito de fundo)

frosted_glass transforma o alfa de qualquer camada em um painel de vidro: dentro dele mostra o composto abaixo, desfocado, tingido e refratado em um bisel, com uma luz de borda. Ele roda após a posição e escala da própria camada, então um painel deslizante fosca o que está realmente sob ele. Quadro de um clipe de 5 s em 1280x720 (exportação levou 15,0 s na máquina de 2 GB); o título fica sobre o painel. magnify transforma o painel em uma lente de aumento. Limites: não para camadas inclinadas em 3D; a refração é um deslocamento de bisel, não uma lente com ray tracing; o fosco é um desfoque de caixa em 3 passagens, não um Gaussiano.

Partículas que atingem coisas

Emissores aceitam colliders (círculo, retângulo ou plano, analítico e determinístico) do qual faíscas quicam com bounce e friction, além de uma força de redemoinho vortex. Da esquerda para a direita: sem obstáculo, um círculo e um plano de chão, um vórtice com um chão (mesma semente). Colisores também podem ser a silhueta alfa de outra camada (kind: layer, clip_id), então faíscas quicam em um título ou forma; a silhueta é lida no quadro atual por padrão; follow: true no colisor usa a silhueta no tempo de cada passo (bins de 0,1 s), então um título animado empurra partículas à sua frente. Limites: partículas não colidem entre si; retângulos finos podem ser atravessados por partículas muito rápidas (60 passos de integração por segundo).

Partículas a partir de uma camada

Um emissor com shape: layer e emit_clip gera na silhueta alfa desse clipe (emit_edge para apenas o contorno), então brasas podem subir das letras de um título; faíscas também podem quicar nele (colliders tipo layer). Mostrado: um clipe de título de 5 s em 1280x720, exportação em 18,8 s. Com emit_follow, cada partícula gera na silhueta como ela era no seu próprio tempo de nascimento (bins de 0,1 s), então um título em movimento ou animado deixa um rastro de suas posições passadas; sem isso, a silhueta no quadro atual é usada. Limite: os bins têm 0,1 s de largura, então uma camada muito rápida pula entre bins, e cada bin custa um render do clipe.

Desfoque de movimento em partículas e em cenas 3D

Ambos aceitam shutter_deg e blur_samples, desativados por padrão. A cena é amostrada em vários instantes ao longo do obturador e calculada a média no espaço pré-multiplicado. O desfoque de cena 3D reposiciona toda a cena por amostra, então animação de objetos, parentesco e movimentos de câmera ficam todos desfocados. Medido em uma cena 1280x720: 0,19 s por quadro desativado, 0,87 s com 8 amostras. Com 8 amostras, um movimento muito rápido mostra cópias escalonadas, então aumente blur_samples.

Rastreamento e estabilização

Rastreadores de ponto, planar e de malha, rastreamento de características com ajustes de homografia, rastreamento de longas lacunas e diagnósticos que relatam tremulação e resíduos. Os quadros abaixo são uma placa de teste sintética (topo: um rótulo fixado em uma superfície em movimento, base: o resultado estabilizado), então mostram o mecanismo, não um resultado com filmagem real. Uma pontuação de confiança não é um bloqueio de pixel, e as ferramentas de validação podem mostrar que um rastreamento não é confiável, não que ele é verdadeiro. Dizemos isso em todos os relatórios.

Por que kimo

• Feito para uma IA, não adaptado. 255 ferramentas, cada uma um comando registrado com um esquema. Nada no editor é acessível apenas pelo mouse. tools/list é agrupado em 16 entradas (15,7 KB em vez de 176 KB, 11,2x menor), com kimo_search para encontrar uma ferramenta por intenção e kimo_describe para seus argumentos, para que uma janela de contexto pequena ainda possa controlar tudo.
• Testado como um servidor deveria ser. Um fuzzer chama cada ferramenta com argumentos gerados antes de qualquer publicação: 255 ferramentas, 9359 chamadas, 0 falhas. Recursos são lançados com uma prova que pode falhar, por exemplo, vidro fosco reduz o detalhe do painel de 114444 para 4473 em uma placa de teste, e um colisor em movimento deixa um corredor de 88 pixels atrás de si, onde um congelado deixa 163.
• Efeitos físicos, não predefinições. Vidro fraturado com refração, desfoque de movimento corrigido por obturador e um núcleo de impacto amortecido. Vidro fosco que congela o que realmente está sob um painel em movimento, com uma lente de aumento. Partículas que colidem com círculos, planos e a silhueta em movimento de uma camada, e que nascem nessa silhueta.
• Rastreamento real, relatado honestamente. Rastreamento de ponto, planar, malha e recursos, estabilização e solução de câmera, com diagnósticos que dizem quando um rastreamento não é confiável em vez de um número de confiança que parece bom.
• Cor profissional. ACES e ACEScct, ASC CDL, OCIO, LUTs, HDR, gráficos de nós de correção, escopos e resposta de filme, em um pipeline de ponto flutuante com saída de 16 bits, EXR e TIFF.
• Pequeno e rápido para iniciar. Um binário estático de 10 MB que responde à primeira solicitação MCP em 2 ms, apenas CPU, otimizado para uma máquina de 2 GB. Uma cena de 5 s em 1280x720 com um vídeo de fundo, um título deslizante, chuva de colisores e brasas exporta em cerca de 40 s nessa máquina.
• Honesto sobre limites. Cada recurso tem um nível em FEATURES.md, com sua linha de base, seu número medido e os casos em que falhou.

O que está dentro

Área	Ferramentas
Linha do tempo e edição	project_set, import_media, add_track, add_clip, move/trim/split/delete, ripple_delete, ripple_trim, roll_edit, slip_clip, slide_clip, markers, multicam, sync_clips, undo/redo, save/load
Aparência e movimento	set_property, set_keyframe (qualquer propriedade, com easing e bezier), expressões, caminhos de movimento, predefinições de movimento, rampas de velocidade, quadro congelado, desfoque de fluxo, tremor de câmera
Efeitos e transições	add_effect, add_transition, modos de mesclagem, máscaras de efeito, camadas de ajuste
Máscaras e roto	máscaras bezier, keyframes de máscara, propagação de roto, mattes de faixa, refine_matte, chroma_key
Texto e gráficos	add_text com animadores e caminhos, legendas, títulos, quadros HUD, contadores, caixas de detecção, formas e formas de caminho com modificadores, estilos de camada
3D e relight	add_scene3d, câmera, luzes, materiais, relight, explosões de fragmentos, vidro fraturado
Partículas e física	add_emitter, add_particles, simulate_physics
Rastreamento e visão	track_point, track_planar, track_mesh, track_features, stabilize, solve_camera, undistort_clip, ferramentas de validação
Cor	primaries, wheels, curves, HSL, LUTs, ACES e ACEScct, ASC CDL, OCIO, HDR, gráficos de nós de correção, escopos, resposta de filme, match_grade
Áudio	fades, EQ, denoise, compressor, echo, pitch, pan, loudness, auto_duck, detecção de batida e vinculação
Saída	render_frame, export, export_alpha, export_gif, export_audio, export_preset, alta profundidade de bits, EXR e TIFF flutuantes

A lista completa e atual de ferramentas é o que tools/list retorna.

Como uma IA vê as ferramentas

O tools/list padrão é agrupado, para que um cliente não precise ler 255 esquemas de ferramentas antecipadamente.

Grupo	O que cobre
project, timeline, animate, effects	projeto e mídia, edições, keyframes e movimento, efeitos e transições
masks, text, graphics, vfx3d	máscaras e roto, texto e legendas, formas e HUD, 3D, partículas e fratura
tracking, color_grade, color_science, scopes	rastreamento e solução de câmera, correção, gerenciamento de cor, medição
audio, output	áudio, render e exportação
kimo_search, kimo_describe	encontrar uma ação por palavras-chave (também pesquisa os catálogos de efeitos e transições), obter os argumentos completos de uma ação

Chame um grupo com {"action": "<tool name>", "args": {...}}, por exemplo {"name": "vfx3d", "action": "add_scene3d", "args": {...}}. Chamar uma ferramenta pelo próprio nome (add_scene3d) ainda funciona, e tools/list com {"mode": "flat"} (ou KIMO_TOOLS=flat) lista todas as 255. Uma nova ferramenta é colocada em um grupo por regras de nome em crates/kimo-core/src/toolgroups.rs, e um teste de unidade falha se uma ficar sem atribuição. tests/group_proof.py verifica se cada ferramenta está em exatamente um grupo e se chamadas agrupadas e diretas dão o mesmo resultado.

Layout

• crates/ - kimo-core (modelo, keyframes, registro de comandos, grupos de ferramentas, renderizador de CPU, efeitos, texto, áudio, rastreamento, cor) e kimo-mcp (o servidor MCP stdio)
• examples/ - cliente Python e demos
• docs/ - notas de design e revisões
• tests/ - o executor de fuzzing de ferramentas

Status: inicial, renderizador de CPU. Veja ROADMAP.md e FEATURES.md.

Contribuindo e a regra do README

O README é atualizado a cada mudança de produto. Se uma mudança adiciona, remove ou reagrupa ferramentas, ou lança uma nova prova, o mesmo commit atualiza este arquivo.

Licenciado sob MIT.