🗺️

O Panorama dos Coding Agents

⏱ 8 min de leitura·+50 XP

Pré-requisitos (0/1)0%

⬜📊 Como Avaliar Modelos de IA(IA Além do LLM)

Recomendamos completar os pré-requisitos antes de seguir, mas nada te impede de continuar.

Em 2021, a OpenAI lançou o GitHub Copilot. Era impressionante: digitava metade de uma função e a IA completava. Em 2025, Claude Code executa tarefas inteiras no seu terminal, lê toda a sua codebase, roda testes e abre PRs sozinho. O que aconteceu no meio?

Três gerações de ferramentas

A evolução aconteceu em três saltos claros. Cada geração não substituiu a anterior — ela expandiu o que é possível:

Geração 1 · 2021–2022Autocomplete Inteligente

O modelo observa o arquivo atual e prevê os próximos tokens. Extremamente rápido, integrado ao editor, sem estado entre sessões. O contexto é o arquivo aberto — nada mais.

Ex: você digita: "function calculateDiscount(" → IA completa os parâmetros e o corpo

GitHub Copilot (original), Tabnine, Codeium

Geração 2 · 2023–2024Chat com Contexto de Código

O LLM recebe não só o arquivo mas também sua pergunta em linguagem natural. Você pode pedir explicações, refatorações, geração de testes. Ainda sem execução autônoma — você cola o resultado.

Ex: "refatora essa função para usar async/await" → IA propõe, você aceita ou recusa

Copilot Chat, Cursor (chat mode), ChatGPT Code Interpreter

Geração 3 · 2024–2025Coding Agents Autônomos

O agente recebe um objetivo, não uma pergunta. Ele mesmo decide quais arquivos ler, quais comandos rodar, como estruturar a solução. Executa múltiplos passos sem intervenção humana a cada etapa.

Ex: "adiciona testes de integração para o módulo de auth" → agente lê o código, escreve os testes, roda, corrige falhas

Claude Code, OpenAI Codex (novo), Cursor Agent, Kiro

O modelo é só um componente

Este é o insight mais importante desta trilha inteira: o LLM em si é apenas uma peça. O que diferencia Claude Code de GitHub Copilot não é (só) a qualidade do modelo — é o harness: a camada de infraestrutura ao redor.

ANATOMIA DE UM CODING AGENT

LLMO modelo (Claude, GPT-4o, Gemini...) — o "cérebro" que raciocina

FerramentasO que o agente pode fazer: ler arquivos, rodar bash, fazer requests HTTP

Loop de execuçãoLógica que decide quando chamar ferramentas, quando parar, quando pedir confirmação

Gestão de contextoComo o histórico da conversa, arquivos relevantes e resultados são incluídos no prompt

Modelo de confiançaO que o agente pode fazer sem confirmar com o usuário — permissões e limites

InterfaceComo o usuário interage: terminal, IDE, chat, API assíncrona

Dois agentes com o mesmo LLM por baixo podem ter comportamentos radicalmente diferentes se o harness for diferente. É por isso que esta trilha compara as ferramentas de dentro para fora — não só o modelo, mas toda a arquitetura.

O loop agêntico: como um agente pensa

Todo coding agent moderno opera em um loop básico chamado ReAct (Reasoning + Acting), formalizado em um paper do Google/Princeton em 2022:

// O loop ReAct simplificado
while (objetivo não alcançado) {
  // REASONING: o LLM pensa sobre o estado atual
  pensamento = LLM.think(contexto + histórico)

  // ACTING: decide qual ferramenta usar
  ação = LLM.decide_tool(pensamento)
  // ex: { tool: "bash", input: "npm test" }

  // OBSERVING: executa e registra o resultado
  resultado = executar(ação)
  contexto.append(resultado)

  // Repete até concluir ou pedir ajuda ao usuário
}

Parece simples — e a ideia central é. A complexidade está nos detalhes: quando interromper para pedir confirmação, como lidar com erros, quanto contexto cabe na janela do modelo, e como evitar loops infinitos.

💡

O paper "ReAct: Synergizing Reasoning and Acting in Language Models" (Yao et al., 2022) é a base teórica de praticamente todos os coding agents modernos. Vale a leitura se você quiser se aprofundar.

Por que agora?

Três coisas precisaram acontecer simultaneamente para os coding agents funcionarem bem:

Janelas de contexto longas

GPT-4 Turbo (128k), Claude 3 (200k), Gemini 1.5 Pro (1M), GPT-5.1-Codex-Max (400k+ efetivo via compactação). Ler uma codebase inteira virou possível.

Tool use confiável

Function calling antes era frágil, hoje é robusto. Os modelos aprenderam a propor chamadas estruturadas com quase zero erro de schema.

Capacidade de seguir instruções longas

Instruction following melhorou drasticamente com RLHF/RLAIF. O modelo segue planos multi-passo sem se perder.

Prompt caching

Mandar 30k tokens de system prompt a cada turno antes era inviável economicamente. Com cache_control, cache hits custam ~10% de tokens novos — destravou sessões longas.

Os modelos estão empatando — o harness não

Um dado que muda a leitura do mercado: no SWE-bench Verified (abril/2026), seis modelos frontier estão dentro de ~0,8 ponto percentual. Claude Opus 4.6, Sonnet 4.6, GPT-5.1, Gemini 3 Pro, Haiku 4.5, codex-max — todos virtualmente empatados.

Ao mesmo tempo, dados do SWE-bench Pro (nov/2025) mostram:

// Mesmo modelo, scaffolds diferentes:
Claude Opus 4.5 em SEAL Harness       →  45,9%
Claude Opus 4.5 em scaffold X         →  ~50%
Claude Opus 4.5 em Claude Code        →  55,4%
// Spread de 9,5 pontos só trocando o harness.

// Modelo "menor" + scaffold bom vs modelo "maior" + scaffold genérico:
Confucius Code Agent + Sonnet 4.5     →  52,7%
Claude Opus 4.5 nativo                →  52,0%
// Sonnet com scaffold dedicado bate Opus sem scaffold.

Ou seja: em 2026, a diferença prática entre ferramentas vem majoritariamente do harness. Isso é contraintuitivo — a narrativa pública foca em "qual modelo é melhor" — mas é o que explica por que Claude Code, Codex e Cursor agent produzem resultados tão distintos usando modelos tão parecidos.

💡

Traduzindo o que isso significa pra você: escolher a ferramenta certa para cada tarefa tem hoje impacto maior do que escolher o modelo mais recente. Essa trilha te equipa pra isso.

💡

No próximo módulo: Claude Code por dentro — com detalhes do código-fonte vazado em 2026: QueryEngine, auto-compact a 98%, Tier 1/2 de permissões, prompt caching.

🧩