# Agent Frameworks vs Coding Agents: Qual a Diferença?

> Entenda a diferença entre frameworks de orquestração como LangGraph e CrewAI e agentes de codificação como Claude Code e Cursor — e quando usar cada.

Source: https://agentify.ia.br/blog/agent-frameworks-vs-coding-agents/

> **TL;DR** — Agent frameworks (LangGraph, CrewAI, AutoGen) são kits de construção para orquestrar agentes autônomos em qualquer domínio. Coding agents (Claude Code, Cursor, Copilot) são agentes prontos, especializados em escrever código no seu terminal ou IDE. O primeiro é uma fábrica de agentes. O segundo já é o agente — pronto pra abrir seu repositório e meter a mão. MCP é a ponte que conecta os dois mundos.

---

Tem uma confusão que aparece toda semana nos fóruns. Alguém pergunta: “devo aprender LangGraph ou usar Claude Code?” — como se fossem alternativas. Não são. É como perguntar se você deve aprender a fabricar motores ou dirigir um carro. Atividades diferentes, camadas diferentes, problemas diferentes.

Mas eu entendo a confusão. Os dois mundos usam a palavra “agente.” Os dois lidam com LLMs. Os dois prometem autonomia. Só que o que cada um faz com essa autonomia muda tudo.

Vamos separar as coisas.

## O que são agent frameworks de orquestração?

Frameworks como LangGraph, CrewAI e o finado AutoGen (agora absorvido pelo Semantic Kernel da Microsoft) são **bibliotecas para construir agentes do zero**. Você define o grafo de estados, os nós de decisão, as transições, as ferramentas disponíveis, a memória, o retry — tudo. Você é o arquiteto.

Pense neles como LEGO pra sistemas autônomos. O LangGraph te dá uma máquina de estados explícita com checkpointing. O CrewAI oferece uma abstração de “equipe” onde cada agente tem um papel (Pesquisador, Escritor, Revisor). O resultado? Um sistema multi-agente customizado para o seu domínio — atendimento ao cliente, análise financeira, pipeline de dados, o que for.

Características que definem esse mundo:

- **Você programa o loop do agente.** Cada transição entre estados, cada decisão de roteamento.

- **Domain-agnostic.** Servem pra qualquer vertical — saúde, finanças, suporte, código, marketing.

- **Output programático.** O resultado pode ser um JSON estruturado, uma chamada de API, um registro no banco.

- **Infra pesada.** Exigem deployment, filas, persistência de estado, observabilidade.

Em julho de 2026, o cenário está assim: LangGraph com 36K stars no GitHub virou o padrão de produção pra workflows stateful. CrewAI ultrapassou 55K stars e passou de 2 bilhões de execuções agênticas. AutoGen entrou em maintenance mode depois que a Microsoft decidiu consolidar tudo no Semantic Kernel — a comunidade fez fork pro AG2, mas o momentum se perdeu. OpenAI lançou o Agents SDK (evolução do Swarm) e Google shipped o ADK em 4 linguagens.

## O que são agentes de codificação?

Agentes de codificação — [Claude Code](/blog/claude-code), [Cursor](/blog/cursor), GitHub Copilot — são **agentes já construídos**, empacotados e prontos pra usar. Você não programa o loop deles. Você dá uma tarefa (“refatora esse módulo”, “escreve testes pra esse service”) e o bicho executa: lê seu repositório, edita arquivos, roda testes, faz commit. Sem cerimônia.

A arquitetura por baixo é o que a indústria está chamando de **agent harness** — um arcabouço que orquestra o ciclo de vida do agente (contexto → modelo → tool call → execução → repeat) com sistema de permissões, compactação de contexto, hooks e spawn de sub-agentes. Você não monta esse harness. Ele vem montado. Sua responsabilidade é dar contexto bom pro agente (via AGENTS.md, regras de projeto, [MCP servers](/blog/ferramentas-tools-e-mcp-servers)) e supervisionar o output.

Características desse mundo:

- **O loop é do agente.** Você configura via regras e hooks, mas não programa as transições.

- **Domain-specific.** Especializados exclusivamente em desenvolvimento de software.

- **Output é código.** Edições em arquivos, comandos no terminal, diffs, PRs.

- **Infra zero (ou quase).** Roda no seu terminal ou IDE. Sem deployment, sem filas, sem banco de estados.

## Como a arquitetura difere na prática?

Deixa eu ser concreto porque teoria sem exemplo é marketing.

Imagina que você quer automatizar code review.

**Com um framework (LangGraph):** Você cria um grafo com nós — `fetch_pr`, `analyze_diff`, `check_style`, `check_security`, `generate_feedback`, `post_comment`. Define as transições. Configura retry e fallback. Faz deploy num servidor. Conecta no webhook do GitHub. Mantém estado em Redis. Monitora com Grafana. Passa duas semanas buildando.

**Com um agente de codificação (Claude Code):** Você escreve no terminal: “revise o PR #42, foque em segurança e estilo, comente no diff.” Ele lê os arquivos, analisa, gera o feedback. Dez minutos.

Isso não significa que o agente de codificação é “melhor.” Significa que resolve um problema diferente. O framework te dá um sistema de code review que roda 24/7, integrado no pipeline, com audit trail. O agente de codificação te dá um review pontual, sob demanda, com supervisão humana.

## Qual é a diferença fundamental? Uma tabela honesta

 Dimensão
 Agent Frameworks
 Coding Agents

 Metáfora
 Fábrica de agentes
 Agente pronto na bancada

 Quem programa o loop
 Você (developer)
 O produto (Anthropic, Cursor Inc.)

 Domínio
 Qualquer vertical
 Desenvolvimento de software

 Output típico
 JSON, API calls, dados estruturados
 Código-fonte, diffs, comandos shell

 Curva de aprendizado
 Alta (LangGraph) a média (CrewAI)
 Baixa — instala e usa

 Infra necessária
 Servidor, filas, DB, observabilidade
 Terminal ou IDE

 Customização
 Total — você define tudo
 Via regras, skills, MCP servers

 Multi-agente
 Core feature — é pra isso que existem
 Disponível (sub-agentes, paralelo )

 Estado entre sessões
 Checkpoint nativo (LangGraph)
 Limitado — baseado em contexto

 Tempo até valor
 Semanas
 Minutos

 Manutenção
 Alta (versões, breaking changes, deploy)
 Baixa (atualiza o app)

## Onde esses dois mundos se cruzam?

Aqui fica interessante — e é onde a maioria dos artigos comparativos para. Porque em 2026, a fronteira está borrada. E o culpado tem nome: **MCP**.

O Model Context Protocol virou o USB-C dos agentes. Tanto frameworks de orquestração quanto coding agents suportam MCP como camada de ferramentas. Isso significa que um MCP server que você escreveu pro seu banco de dados funciona igualmente bem plugado no LangGraph e no [Claude Code](/blog/ferramentas-tools-e-mcp-servers).

Cruzamentos concretos:

- **Coding agents construídos COM frameworks.** Nada impede (e já acontece) de usar LangGraph pra construir um agente de codificação customizado. Empresas que precisam de controle fino sobre o fluxo de review, deploy e teste montam pipelines agênticos com frameworks — onde um dos nós é literalmente “chamar um LLM pra escrever código.”

- **Coding agents que ORQUESTRAM.** Claude Code e Cursor já fazem multi-agente internamente. Claude Code [spawna sub-agentes em paralelo](/blog/multi-agente-trabalhando-em-paralelo) pra tarefas independentes. É orquestração — só que embutida no harness, não exposta pra você programar.

- **MCP como protocolo universal.** Os [MCP servers](/blog/ferramentas-tools-e-mcp-servers) que você instala no Cursor servem igualmente num agente construído com CrewAI. A camada de ferramentas convergiu.

- **Agent-to-Agent (A2A).** O protocolo do Google (2025) permite que agentes de qualquer tipo se comuniquem entre si. Em tese, um agente de codificação pode colaborar com um agente de análise construído num framework. Na prática, isso ainda é early days.

## Quando usar um agent framework?

Usa LangGraph, CrewAI ou similar quando:

- **O problema não é código.** Você quer automatizar atendimento ao cliente, análise de documentos, pipeline de dados, workflows de aprovação.

- **Precisa de controle sobre o fluxo.** Quer definir exatamente qual agente fala com qual, em qual ordem, com quais fallbacks.

- **Precisa de estado persistente.** O workflow dura horas ou dias. Tem human-in-the-loop. Tem checkpoints.

- **Escala é requisito.** Centenas de execuções paralelas, filas, retries, observabilidade enterprise.

- **Multi-agente é o core.** Vários agentes especializados colaborando num resultado — e você precisa orquestrar quem faz o quê.

O custo: semanas de setup, infra dedicada, complexidade operacional. Aquele estudo da Accio reportou 60% menos erros e 40% menos TCO em empresas que migraram de chains sequenciais pra frameworks de orquestração — mas isso é em contexto enterprise, com equipe de plataforma, budget, e problemas complexos o suficiente pra justificar.

## Quando usar um agente de codificação?

Usa [Claude Code](/blog/claude-code), [Cursor](/blog/cursor) ou Copilot quando:

- **O problema é código.** Implementar features, refatorar, debugar, migrar, escrever testes, fazer review.

- **Quer resultado imediato.** Sem setup, sem deploy. Instala, configura as regras do projeto, e manda a tarefa.

- **Supervisão humana é natural.** Você está ali, no terminal ou IDE, revisando o output em tempo real.

- **O contexto é o repositório.** O agente precisa entender a base de código existente — imports, padrões, convenções.

- **Multi-agente é bonus, não core.** Sub-agentes ajudam na velocidade, mas o fluxo principal é um agente conversando com você.

O custo: menos controle sobre o “como.” Você não define cada transição. Se o agente toma um caminho ruim, você corrige via prompt, não via código. A customização é via regras declarativas (AGENTS.md,.cursor/rules), não via grafo programático.

## E o argumento do “single agent basta”?

Esse debate tá quente. O Sahil Lavingia (fundador do Gumroad) postou em julho de 2026 que um único agente gerencia 99.98% das operações do Gumroad. Sem framework multi-agente, sem orquestração elaborada. Um agente com boas ferramentas e pronto.

Ele tem razão — pra certas classes de problema. Se o domínio é bem definido, as ferramentas são estáveis, e o fluxo é linear, um agente com acesso às tools certas é suficiente. É exatamente o modelo dos coding agents: um agente poderoso, com muitas ferramentas (filesystem, terminal, browser, MCP servers), supervisionado por humano.

O ponto onde isso quebra: quando o fluxo não é linear, quando agentes precisam se especializar em sub-domínios diferentes, quando a escala exige paralelismo coordenado. Aí frameworks de orquestração justificam sua complexidade.

Mas aqui vai minha opinião: a maioria dos devs que ficam meses estudando LangGraph estariam melhor servidos usando um agente de codificação bem configurado. O problema deles é escrever código mais rápido — não orquestrar sistemas multi-agente enterprise. É fácil se perder na abstração e esquecer o problema original.

## O que isso significa pro seu dia-a-dia?

Se você é dev e quer ser mais produtivo com IA, **comece pelos agentes de codificação.** Configure [Claude Code](/blog/claude-code) ou [Cursor](/blog/cursor) com boas regras de projeto. Aprenda a dar contexto. Aprenda a usar [MCP servers](/blog/ferramentas-tools-e-mcp-servers). Aprenda a trabalhar com [sub-agentes em paralelo](/blog/multi-agente-trabalhando-em-paralelo). Isso resolve 90% dos casos.

Se você precisa construir um sistema agêntico — um pipeline que roda sem supervisão, que coordena múltiplos agentes, que mantém estado, que escala — aí sim, aprenda um framework. LangGraph é o mais robusto pra produção. CrewAI é mais rápido pra prototipar.

E se você está construindo um produto que usa IA? Provavelmente vai combinar os dois. Um framework orquestrando o backend. Um coding agent acelerando o desenvolvimento do framework. Meta? Sim. Mas é 2026 e os agentes de codificação literalmente ajudam a construir os frameworks que orquestram outros agentes.

## Próximos passos

Se você chegou até aqui e quer aprofundar:

- **Quer dominar coding agents?** Leia o guia completo de [Claude Code](/blog/claude-code) e o de [Cursor](/blog/cursor). Configure AGENTS.md no seu projeto. Instale [MCP servers](/blog/ferramentas-tools-e-mcp-servers) relevantes.

- **Quer entender multi-agente na prática?** Veja como [trabalhar com agentes em paralelo](/blog/multi-agente-trabalhando-em-paralelo) já funciona nos coding agents — sem precisar de framework.

- **Quer construir um sistema de orquestração?** LangGraph é o ponto de entrada. Mas saiba que você está entrando num mundo de infra, não de coding assistido.

A pergunta certa não é “qual é melhor?” — é “qual problema eu estou resolvendo?” Se a resposta envolve escrever código, os coding agents são seu caminho. Se envolve orquestrar sistemas autônomos num domínio específico, frameworks. Se envolve os dois — e cada vez mais vai envolver — bem-vindo ao clube. A gente se vê no terminal.

-->