Como Usar Kimi K3 para Programar com Kimi Code

A Moonshot AI construiu o Kimi K3 para trabalhos de codificação que não se encaixam em um único prompt. A proposta é engenharia de longo prazo: apontar um modelo para um grande repositório, deixá-lo ler arquivos, executar ferramentas, rodar testes, ler os logs e capturas de tela que retornam, e iterar até que a tarefa seja concluída. Isso é um trabalho diferente do autocompletar, e exige um agente de codificação envolvido no modelo. A Moonshot oferece um chamado Kimi Code. Este guia aborda como executar o K3 nele, como é um loop agêntico real, onde ele se encaixa ao lado de Claude Code e Cursor, e onde ele honestamente fica aquém.

TL;DR: executando o Kimi K3 para codificação

O Kimi K3 é o modelo principal da Moonshot AI, lançado em 16 de julho de 2026, com uma janela de contexto de 1 milhão de tokens e uma arquitetura ajustada para trabalhos em escala de repositório. Você programa com ele através do Kimi Code, o agente de codificação de terminal e IDE da Moonshot: selecione o modelo com um comando /model e atribua-lhe uma tarefa. O K3 é forte na navegação de grandes bases de código, usando ferramentas, depurando e iterando com base em imagens, logs, testes e feedback de tempo de execução. É econômico em loops intensivos em cache graças a uma taxa de acerto de cache relatada de mais de 90%, mas não é o mais rápido, com aproximadamente 62 tokens por segundo, e a própria Moonshot diz que ele ainda fica atrás do Claude Fable 5 e do GPT-5.6 Sol em capacidade bruta. Quando o K3 constrói uma API para você, o Apidog é a maneira mais rápida de acessar os endpoints que ele gera e confirmar seu comportamento. Para o histórico do modelo, comece com o que é Kimi K3.

O que é Kimi Code

O Kimi Code é o agente de codificação da Moonshot. Ele é executado no seu terminal (e se integra ao seu IDE), lê e escreve arquivos, executa comandos shell e conduz uma sessão de engenharia completa em seu nome, em vez de apenas responder a uma pergunta. Abra-o dentro de um diretório de projeto, descreva o que você quer, e ele planeja, edita, executa e verifica seu próprio trabalho em um loop. O modelo por si só é um motor de texto e ferramenta; o Kimi Code é o arcabouço que lhe dá um sistema de arquivos, um shell, saída de testes e capturas de tela para trabalhar. Esse arcabouço transforma "um modelo que é bom em código" em "um agente que pode fechar um ticket".

O Kimi Code não é novidade com o K3; a linha anterior do Kimi K2 rodava no mesmo agente. Nosso guia da CLI do Kimi Code abrange o passo a passo da instalação do zero, e como usar a CLI do Kimi é a referência mais ampla da linha de comando. Este artigo assume que a CLI está instalada e se concentra em operar o K3.

Colocando o Kimi K3 para funcionar no Kimi Code

O comando de instalação e os sinalizadores exatos mudam à medida que a Moonshot atualiza a ferramenta, então trate os passos abaixo como a estrutura do fluxo de trabalho e confirme a sintaxe precisa na documentação oficial do Kimi ou em nosso guia da CLI do Kimi Code. Os comandos são representativos, não exatos.

1. Instale o agente e autentique-se. Instale a ferramenta de linha de comando uma vez, depois faça login para que ela possa acessar a API do Kimi. Você precisará de uma conta Kimi e uma chave de API da plataforma de desenvolvedor Kimi. Armazene a chave como uma variável de ambiente em vez de colá-la em um arquivo de configuração que você possa cometer por acidente.

# Representativo, não exato. Verifique a documentação oficial para a sintaxe atual.
export KIMI_API_KEY="sua-chave-aqui"
kimi-code   # inicia o agente no diretório atual

2. Abra-o dentro do seu projeto. Mude para o repositório e inicie o agente lá. O Kimi Code trata o diretório atual como sua raiz de trabalho e lê a estrutura do projeto para construir o contexto, então o local onde você o inicia é importante.

3. Selecione K3 como o modelo. Dentro da sessão, troque o modelo ativo com o comando /model e escolha kimi-k3. Este é o mesmo mecanismo que você usaria para alternar entre o K3 e modelos mais antigos, como o Kimi K2.7 Code focado em codificação, na mesma tarefa.

/model kimi-k3

4. Defina o esforço de raciocínio. O K3 expõe um esforço de raciocínio configurável, incluindo uma configuração "máxima". Para depuração difícil ou uma grande refatoração, mais pensamento ajuda; para edições rápidas, diminua-o para não pagar por uma profundidade que você não precisa.

Uma vez que o modelo é selecionado e o agente aponta para o seu repositório, você está pronto para atribuir-lhe trabalho. Para experimentar o K3 sem instalar o Kimi Code, ou sem custo, como usar o Kimi K3 gratuitamente aborda os caminhos sem custo.

Um fluxo de trabalho de codificação agêntica prático

O padrão é o mesmo, seja para corrigir um bug ou lançar um recurso: dê ao K3 uma tarefa concreta, deixe-o coletar contexto e faça-o comprovar o resultado contra algo objetivo.

Aponte-o para o repositório e dê uma tarefa clara

Instruções vagas produzem trabalho vago. Em vez de "melhorar o módulo de autenticação", dê ao agente uma tarefa que ele possa verificar: "O endpoint /login retorna um erro 500 quando o campo de senha está vazio. Reproduza-o, encontre a causa, corrija-o e adicione um teste que cubra o caso de senha vazia." Um objetivo específico e testável é a maior alavanca na qualidade da saída: ele dá ao agente uma linha de chegada para se auto-verificar.

O contexto de 1 milhão de tokens do K3 é o que torna "apontá-lo para todo o repositório" realista: o agente mantém uma grande parte da sua base de código de uma só vez, rastreando uma chamada do manipulador de rota através da camada de serviço sem que você precise alimentá-lo com os arquivos corretos. A Moonshot cita a navegação em grandes repositórios como um ponto forte central do K3.

Deixe-o usar ferramentas e ler o feedback

É aqui que um agente se justifica. O K3 suporta chamadas de ferramentas, então dentro do Kimi Code ele pode executar sua suíte de testes, pesquisar na base de código, executar um build ou acessar um serviço em execução, e então ler o que retorna:

1. O agente lê os arquivos relevantes e formula uma hipótese.
2. Ele faz uma edição.
3. Ele executa os testes ou o aplicativo.
4. Ele lê a saída com falha, o rastreamento de pilha ou a linha de log.
5. Ele revisa e repete até que as verificações sejam aprovadas.

A Moonshot chama o K3 de "particularmente forte na navegação de grandes repositórios, usando ferramentas, depurando e iterando com base em imagens, logs, testes e feedback de tempo de execução". Esse loop é o coração do fluxo de trabalho: você não está pedindo ao modelo para acertar na primeira tentativa, mas para executar, observar e corrigir como um engenheiro humano.

Itere com base em imagens e saída de tempo de execução

O feedback não se limita a texto. A Moonshot destaca o raciocínio visual como parte do alcance do K3: o agente pode ler uma captura de tela para confirmar se uma mudança de frontend foi renderizada corretamente, ou usar uma imagem capturada para guiar o desenvolvimento de jogos e trabalhos de CAD. Assim, um loop de UI é: mudar o CSS, renderizar, capturar tela, ajustar. Para trabalhos de backend, o feedback é um relatório de teste, um fluxo de log ou uma resposta HTTP, e o loop é o mesmo.

Mantenha o loop honesto com testes

Testes impedem que um loop autônomo se desvie. Com uma suíte de testes aprovada como objetivo, o agente tem um sinal claro de "concluído" e "quebrado"; sem isso, uma execução longa pode divagar e silenciosamente quebrar algo a três arquivos de distância. Escreva o teste primeiro, então deixe o K3 iterar até que esteja verde.

Kimi K3 vs Claude Code e Cursor para codificação

O K3 no Kimi Code não é a única configuração de codificação agêntica. Aqui está uma comparação honesta lado a lado das três maneiras mais comuns de executar um agente na sua base de código em meados de 2026.

Algumas conclusões. Para a maior confiabilidade bruta em uma tarefa difícil, o Fable 5 no Claude Code é o modelo que a própria Moonshot admite estar à frente do K3. Se você deseja o agente dentro de um editor refinado, ferramentas no estilo Cursor e Cline se encaixam melhor, e você pode executar outros modelos abertos através delas, como mostra nosso guia GLM-5.2 no Claude Code, Cline e Cursor. A vantagem do K3 é um contexto muito grande, forte navegação de repositório e precificação construída para os loops longos e repetitivos que elevam a conta em um modelo fronteira por token. Uma vez que os pesos forem lançados, é o único dos três que você pode auto-hospedar.

Pontos fortes e limites honestos

No que o K3 é bom

Contexto em escala de repositório. A janela de 1M de tokens permite que o agente mantenha uma grande base de código em vista de uma só vez, reduzindo o problema de “quais arquivos devo dar a ele” que atrapalha modelos de contexto menor em trabalhos com monorepos.

Uso de ferramentas e autonomia de longo prazo. O K3 foi ajustado para sustentar sessões de engenharia prolongadas com o mínimo de intervenção manual, orquestrando ferramentas de terminal e corrigindo-se com base em saídas reais. Isso é o que separa fechar um ticket de sugerir um trecho de código.

Custo em loops intensivos em cache. A codificação agêntica reenvia o mesmo contexto (árvore de arquivos, prompt do sistema, instruções) a cada passo. O preço de entrada do K3 para acerto de cache é de $0.30 por milhão de tokens versus $3.00 em caso de falha, uma diferença de 10x, e a inferência Mooncake da Moonshot relata uma taxa de acerto de cache acima de 90% em cargas de trabalho de codificação. Assim, o padrão que torna os loops de agente caros em outros lugares é onde o K3 permanece barato. Os números completos estão na análise de preços do Kimi K3.

Onde o K3 fica aquém

Não é a fronteira, e a Moonshot o diz. O post de lançamento afirma claramente que o K3 "ainda fica atrás dos modelos proprietários mais poderosos, Claude Fable 5 e GPT-5.6 Sol." Nos benchmarks de codificação publicados pela Moonshot, o cenário é próximo, mas consistente: no Terminal Bench 2.1, o K3 pontua 88.3 contra 88.8 do GPT-5.6 Sol, e no DeepSWE ele registra 67.5 contra 70.0 do Fable 5 e 73.0 do GPT-5.6 Sol. Competitivo, não o primeiro. Veja a análise dos benchmarks do Kimi K3 para o panorama completo.

Não é rápido. Na listagem da Artificial Analysis, o K3 gera cerca de 62 tokens por segundo, abaixo da média para sua faixa de preço, e seu padrão inclina-se para o esforço máximo de raciocínio. Em um loop interativo onde você observa o fluxo de saída, isso é perceptível. Se a velocidade importa mais do que os últimos pontos de qualidade, teste primeiro um modelo mais rápido.

"Aberto" é um evento programado. Os pesos completos são esperados por volta de 27 de julho de 2026, não no dia do lançamento. Se o seu plano depende de auto-hospedagem, essa é uma data para observar, em vez de um interruptor que você pode ligar agora.

Para as comparações diretas, veja Kimi K3 vs Claude Opus 4.8, Kimi K3 vs GPT-5.6 Sol, e Kimi K3 vs Kimi K2.7 Code, que aborda a atualização do anterior campeão de codificação na linhagem.

Casos de uso no mundo real

O K3 se destaca nos trabalhos para os quais o fluxo de trabalho acima foi construído: grandes refatorações em um monorepo, onde o contexto de 1M mostra todo o impacto de uma vez para que ele possa trabalhar nas edições até que a compilação esteja verde; longas sessões de depuração, onde ele reproduz uma falha, lê o rastreamento de pilha, corrige e executa novamente sem sua supervisão; e na construção de uma API, onde ele estrutura o handler, a rota e, muitas vezes, os testes, para então passar para uma ferramenta de API dedicada para verificação.

Verificando as APIs que o K3 constrói

Quando o K3 constrói ou modifica uma API dentro do Kimi Code, seus próprios testes informam que o código funciona. Eles não informam se o endpoint se comporta da maneira que um cliente real espera: códigos de status corretos, o formato de resposta certo, tratamento de erros sensato, autenticação que rejeita um token inválido. Isso é um trabalho de teste de API.

É aqui que o Apidog se encaixa. Envie requisições reais para o endpoint gerado, inspecione o corpo e os cabeçalhos da resposta, e adicione asserções sobre o código de status e o formato JSON. Se o agente produziu uma especificação OpenAPI, importe-a e o Apidog constrói a coleção de requisições para você, para que você valide contra o contrato em vez de adivinhar. Mantenha suas chaves em variáveis de ambiente do Apidog para que nunca vazem para uma coleção compartilhada.

Como o Apidog expõe uma interface MCP, você também pode conectar suas ferramentas de API diretamente ao contexto de um agente; nosso guia sobre depuração visual com o cliente MCP do Apidog mostra como, e o Apidog no VS Code mantém o loop de teste ao lado do código que o K3 escreve. Baixe o Apidog para verificar a saída do modelo no momento em que ela chega, em vez de confiar apenas em uma execução de teste bem-sucedida.

Onde isso te deixa

O Kimi K3 é um agente de codificação genuinamente capaz no Kimi Code quando você aproveita para o que ele foi construído: grandes repositórios, longos loops autônomos e iteração constante contra testes, logs e capturas de tela. O contexto de 1M e o preço por acerto de cache o tornam prático exatamente para o trabalho exaustivo e multifacetado que se torna caro rapidamente em outros lugares. Não é o melhor codificador disponível, e a Moonshot merece crédito por admitir isso, mas para muitos trabalhos reais a diferença é pequena e as vantagens de custo e abertura são reais. Comece com uma tarefa concreta e testável, deixe o K3 iterar e verifique as APIs que ele produz com o Apidog antes de lançar. Para o histórico do modelo, o pilar o que é Kimi K3 e o guia da API do Kimi K3 dão continuidade a partir daí.

Perguntas frequentes

Como uso o Kimi K3 para codificação? Execute-o dentro do Kimi Code, o agente de codificação de terminal e IDE da Moonshot. Instale o agente, abra-o no seu diretório de projeto, selecione o modelo com /model kimi-k3, então dê a ele uma tarefa concreta e testável e deixe-o ler arquivos, executar ferramentas e iterar. O passo a passo completo da instalação está em nosso guia da CLI do Kimi Code.

O Kimi K3 é bom para codificação agêntica? Sim. Ele é ajustado exatamente para o que a codificação agêntica precisa: navegar por grandes repositórios, usar ferramentas, depurar e iterar com base em testes, logs e feedback de tempo de execução em um contexto de 1M de tokens. Ele é competitivo em benchmarks de codificação, embora fique ligeiramente atrás do Fable 5 e do GPT-5.6 Sol.

O Kimi K3 suporta chamadas de ferramentas para fluxos de trabalho de agente? Sim. A API do K3 suporta chamadas de ferramentas, restrições de escolha de ferramentas, modo JSON, saída estruturada, pesquisa na internet, carregamento dinâmico de ferramentas e esforço de raciocínio configurável, que é o que permite executar testes, comandos shell e orquestrar um loop completo de agente dentro do Kimi Code. O guia da API do Kimi K3 abrange os detalhes do lado do desenvolvedor.

Posso testar as APIs que o Kimi K3 escreve? Sim, e você deve. Os próprios testes do agente confirmam que o código funciona, mas não que o endpoint retorna os códigos de status corretos, o formato de resposta e o comportamento de autenticação que um cliente real espera. Envie requisições reais para os endpoints gerados no Apidog, adicione asserções e importe qualquer especificação OpenAPI que o agente tenha produzido para validar contra o contrato.