Como construir seu primeiro loop de agente de IA com o Kimi K3 (Configuração completa incluída)

Um loop de agente é a diferença entre pedir ajuda à IA e acordar com o trabalho pronto. A maioria das pessoas nunca constrói um porque cem iterações em um modelo de ponta custa dinheiro de verdade.

Aqui dentro: o padrão de loop explicado em um diagrama, duas configurações exatas (Claude Code e API pura) e a matemática do cache que faz do K3 a máquina de loops.

Seu primeiro loop roda hoje à noite por cerca de US$ 0,39 por turno.

Aqui está a configuração completa 👇

Antes de mergulharmos, compartilho notas diárias sobre IA e vibe coding no meu canal do Telegram: https://t.me/zodchixquant 🧠

O que realmente é um loop

Tire o hype e um loop são quatro passos repetidos:

1GOAL → ATTEMPT → CHECK → (better? keep : retry)
2        ↑__________________________|

• Goal: uma linha de chegada mensurável, não uma sensação. "Todos os testes passam", "página carrega em menos de 1s", "nota acima de 90"
• Attempt: o modelo realiza uma unidade de trabalho em direção a ela
• Check: algo verifica o resultado em relação ao objetivo. Um conjunto de testes, um linter, um segundo modelo
• Repeat: alimente o resultado da verificação de volta, vá de novo, pare quando o objetivo for atingido ou o orçamento acabar

É isso. Todo o resto (memória, subagentes, execuções noturnas) é decoração neste ciclo.

Por que K3 especificamente: a economia do loop

Loops releem o mesmo contexto a cada turno: o código, o objetivo, o histórico. Na maioria dos modelos, você paga o preço total por essa repetição. No K3, não:

1Custo por turno = fresh_tokens × $3/M + cached_tokens × $0,30/M
2
3Forma real (800K de contexto estável + 50K de novos por turno):
4K3:       $0,24 + $0,15 = $0,39/turno
5Fable 5:  850K × $10/M  = $8,50/turno

Um loop noturno de 50 turnos: cerca de US$ 20 no K3, cerca de US$ 425 no Fable 5. Isso não é um desconto, é a diferença entre "deixar rodar" e "vigiar como um falcão".

A única regra: mantenha seu contexto estável como um prefixo idêntico a cada turno, a tarefa no final, para que o cache realmente funcione.

Setup A: Claude Code (o caminho de 5 minutos)

Se você vive no Claude Code, loops são nativos e o K3 se encaixa por baixo via a configuração oficial da Moonshot:

1export ANTHROPIC_BASE_URL=https://api.moonshot.ai/anthropic
2export ANTHROPIC_AUTH_TOKEN=${YOUR_MOONSHOT_API_KEY}
3export ANTHROPIC_MODEL=kimi-k3
4export ANTHROPIC_DEFAULT_OPUS_MODEL=kimi-k3
5export ANTHROPIC_DEFAULT_SONNET_MODEL=kimi-k3
6export ANTHROPIC_DEFAULT_HAIKU_MODEL=kimi-k3
7export CLAUDE_CODE_SUBAGENT_MODEL=kimi-k3
8export ENABLE_TOOL_SEARCH=false
9export CLAUDE_CODE_AUTO_COMPACT_WINDOW=1048576
10claude

Então o loop são dois comandos:

• /goal define a linha de chegada: "todos os testes em tests/ passam e a cobertura permanece acima de 80%". O Claude Code continua trabalhando em direção a isso em vez de parar na primeira resposta
• /loop o torna recorrente: a sessão é reexecutada em um cronograma ou até que o objetivo seja mantido

Confirme que você está no K3 via /status (o menu /model não mostrará). A janela de compactação automática de 1M na configuração significa que loops longos compactam raramente, o que mantém o histórico de iteração vivo.

Setup B: o loop de API puro (controle total)

Para loops fora do Claude Code, aqui está um loop mínimo completo, compatível com OpenAI:

1from openai import OpenAI
2
3client = OpenAI(
4    api_key=MOONSHOT_API_KEY,
5    base_url="https://api.moonshot.ai/v1",
6)
7
8# Prefixo estável: idêntico a cada turno = hits de cache a $0,30/M
9STABLE = f"""Você é um agente de codificação em um loop.
10OBJETIVO: fazer todos os testes passarem no projeto abaixo.
11PROJETO:
12{project_dump}
13REGRAS:
14- Uma mudança focada por turno
15- Explique o que você mudou e por que em 2 linhas
16- Se os testes passarem, responda exatamente: GOAL_REACHED
17"""
18
19history = []
20MAX_TURNS = 30
21
22for turn in range(MAX_TURNS):
23    result = run_tests()          # sua verificação: pytest, npm test, etc.
24    if result.passed:
25        print(f"Concluído em {turn} turnos")
26        break
27
28    response = client.chat.completions.create(
29        model="kimi-k3",
30        messages=[
31            {"role": "system", "content": STABLE},
32            *history[-6:],        # últimas 3 trocas, limitadas
33            {"role": "user", "content":
34                f"Turno {turn}. Saída do teste:\n{result.output}\n"
35                f"Corrija a próxima falha."},
36        ],
37    )
38    change = response.choices[0].message.content
39    apply_change(change)          # escreve a edição, commit em um branch
40    history += [
41        {"role": "user", "content": f"Turno {turn} saída do teste fornecida"},
42        {"role": "assistant", "content": change},
43    ]

Três detalhes importantes:

• A verificação é código, não sensações. run_tests() decide o progresso, o modelo nunca se avalia
• O histórico é limitado. Apenas as últimas 3 trocas; o prefixo estável carrega o contexto durável e permanece amigável ao cache
• Toda mudança vai para um branch. O loop pode estar errado 10 vezes, desde que a main nunca veja

Salvaguardas antes de você se afastar

• Limite de orçamento: conte tokens por turno, mate o loop em um limite de dólar. MAX_TURNS não é suficiente, um turno inchado pode consumir mais que dez normais
• Limite de progresso: se o mesmo teste falhar 3 turnos seguidos, pare e sinalize. Loops que não convergem queimam dinheiro educadamente
• Uma pegadinha do K3: raciocínio roda apenas em max-only por enquanto, então cada turno carrega saída completa de pensamento a US$ 15/M. Mantenha os turnos focados, uma falha por turno, e o lado da saída permanece controlável

Erros comuns

• Objetivos vagos. "Melhorar o código" loops para sempre. Um loop é tão bom quanto sua linha de chegada é verificável
• Deixar o modelo se autoavaliar. "Parece correto para mim" é como loops entregam lixo. O verificador deve ser externo: testes, linter ou um segundo modelo com uma rubrica
• Quebrar o cache. Carimbos de data/hora, IDs aleatórios ou arquivos reordenados no seu prefixo significam que cada turno custa US$ 3/M em vez de US$ 0,30. Idêntico significa idêntico
• Sem disciplina de branch. Um loop não supervisionado com acesso de escrita à main é uma história de terror com etapas extras
• Começar com execuções noturnas. Rode seus primeiros loops enquanto observa, 10-15 turnos. Ganhe a confiança antes de dormir sobre ele

A configuração de 15 minutos

1. Pegue uma chave de API da Moonshot, recarregue dentro da janela de bônus de 10-30%, válida até 11 de agosto (3 min)
2. Escolha o Setup A ou B e configure (5 min)
3. Escreva um objetivo verificável para uma tarefa real pequena: um teste falhando, uma passagem de lint (2 min)
4. Rode 10 turnos supervisionados, veja a verificação direcionar o trabalho (4 min)
5. Anote o custo. Então decida quão grande será o próximo loop (1 min)

O loop é a ideia mais antiga da programação aplicada à ferramenta mais nova. O K3 apenas tornou barato o suficiente para realmente usar.

Obrigado por ler!

Compartilho notas diárias sobre IA e vibe coding no meu canal do Telegram: https://t.me/zodchixquant 🧠