LangGraph vs CrewAI vs OpenAI Agents SDK: o guia técnico para escolher seu framework de agentes em 2026

Três frameworks, um problema: você precisa colocar um agente de IA em produção e não sabe qual stack escolher. Eu construí o mesmo agente — pesquisa web, análise de resultados, geração de relatório — em LangGraph, CrewAI e OpenAI Agents SDK. Esse post é o resultado.

Não é review de documentação. É código rodando, com números.

O cenário do teste

O agente é simples de propósito. Três etapas:

Pesquisa web — recebe um tema, busca fontes relevantes
Análise — filtra e ranqueia os resultados por relevância
Relatório — gera um resumo estruturado com citações

Se um framework não consegue fazer isso bem, não merece estar na conversa. Se consegue, a pergunta passa a ser: com quantas linhas de código, quanto tempo de setup e quão fácil é debugar quando algo quebra às 2h da manhã.

LangGraph: controle total, complexidade proporcional

Repo: github.com/langchain-ai/langgraph — 27.100 buscas mensais no Google, o que mostra que muita gente está pelo menos curiosa.

LangGraph modela o agente como um grafo direcionado com estado. Cada nó é uma função, cada aresta é uma transição condicional. Você define explicitamente o fluxo: qual nó executa depois de qual, sob quais condições, com qual estado compartilhado.

Para o nosso agente de três etapas, o código ficou assim (simplificado):

from langgraph.graph import StateGraph, END

graph = StateGraph(AgentState)
graph.add_node("search", search_web)
graph.add_node("analyze", analyze_results)
graph.add_node("report", generate_report)
graph.add_edge("search", "analyze")
graph.add_edge("analyze", "report")
graph.add_edge("report", END)

app = graph.compile(checkpointer=MemorySaver())

O resultado: ~120 linhas para o agente completo com estado, checkpointing e retry. O StateGraph te dá controle absoluto sobre o fluxo — você sabe exatamente o que vai executar e quando. O checkpointer salva estado entre etapas, o que significa que se a etapa de análise falhar, você retoma dali sem reprocessar a pesquisa.

Onde brilha: workflows complexos com branching condicional, loops de feedback e estado persistente. Se o seu agente precisa decidir entre cinco caminhos possíveis baseado no output da etapa anterior, LangGraph é onde você quer estar.

Onde dói: a curva de aprendizado. Modelar tudo como grafo é poderoso, mas verboso. Para um agente linear de três etapas, parece overengineering. E o ecossistema LangChain como dependência transitiva ainda carrega bagagem — eu gastei mais tempo resolvendo imports do que escrevendo lógica de negócio.

CrewAI: multi-agente role-based, prototipagem rápida

Repo: github.com/crewAIInc/crewAI — 44.600 stars no GitHub, v1.10.1 em março de 2026.

CrewAI pensa diferente. Em vez de nós num grafo, você define agentes com papéis e tarefas. O framework cuida da orquestração. Para o nosso caso:

from crewai import Agent, Task, Crew

researcher = Agent(
    role="Pesquisador Web",
    goal="Encontrar fontes relevantes sobre o tema",
    tools=[SerperTool()],
    llm="gpt-4o"
)

analyst = Agent(
    role="Analista de Conteúdo",
    goal="Filtrar e ranquear resultados por relevância",
    llm="gpt-4o"
)

writer = Agent(
    role="Redator de Relatórios",
    goal="Gerar relatório estruturado com citações",
    llm="gpt-4o"
)

crew = Crew(
    agents=[researcher, analyst, writer],
    tasks=[search_task, analyze_task, report_task],
    process=Process.sequential
)

result = crew.kickoff(inputs={"topic": "AI agents 2026"})

~75 linhas para o agente completo. Cerca de 40% menos código que o LangGraph para o mesmo resultado. E o tempo de prototipagem caiu proporcionalmente — do pip install ao primeiro output funcional, foram 22 minutos contra 38 no LangGraph.

O grande diferencial em 2026: suporte nativo a MCP (Model Context Protocol) e A2A (Agent-to-Agent). O CrewAI v1.10 trata MCP como cidadão de primeira classe. Conectar um servidor MCP é uma linha de config, não um wrapper custom. E o protocolo A2A permite que crews diferentes se comuniquem entre si — o que abre a porta para arquiteturas multi-equipe que eram impraticáveis há seis meses.

Onde brilha: prototipagem. Se você precisa validar uma ideia de agente multi-step com stakeholders na terça, CrewAI é a resposta. A abstração role-based é intuitiva para times que pensam em termos de “quem faz o quê” em vez de “qual nó conecta com qual”.

Onde dói: controle fino. Quando o agente precisa tomar decisões complexas de roteamento, a abstração role-based começa a vazar. Eu precisei de um hack para implementar retry condicional na etapa de análise — algo que no LangGraph seria uma aresta no grafo. E o debugging de interações entre agentes ainda é opaco: quando o analista recebe lixo do pesquisador, o stack trace não ajuda muito.

OpenAI Agents SDK: o novo na área

Repo: github.com/openai/openai-agents-python — lançado em 2026, lightweight e opinionated.

O Agents SDK da OpenAI é o mais recente dos três e não tenta esconder sua proposta: se você já usa modelos OpenAI, esse é o caminho de menor fricção.

from openai_agents import Agent, Runner

search_agent = Agent(
    name="researcher",
    instructions="Pesquise fontes relevantes sobre o tema dado.",
    tools=[web_search_tool],
    model="gpt-4o"
)

analysis_agent = Agent(
    name="analyst",
    instructions="Analise e ranqueie os resultados por relevância.",
    model="gpt-4o"
)

report_agent = Agent(
    name="writer",
    instructions="Gere relatório estruturado com citações.",
    model="gpt-4o"
)

result = Runner.run(
    search_agent,
    handoffs=[analysis_agent, report_agent],
    input="AI agents 2026"
)

~60 linhas. O mais enxuto dos três. O conceito de handoffs entre agentes é elegante — cada agente decide quando passar a bola para o próximo, e o Runner gerencia o ciclo de vida.

Onde brilha: simplicidade e integração nativa com a API da OpenAI. Tracing vem embutido. O guardrail system é nativo. Se sua stack já é OpenAI de ponta a ponta, a integração é quase zero-config.

Onde dói: lock-in. O SDK assume modelos OpenAI. Usar Claude ou Gemini exige adaptadores que não são oficiais. E para workflows complexos com estado persistente, o modelo de handoffs é limitado — não tem checkpointing nativo, não tem branching condicional explícito. É opinado no bom sentido quando seu caso é simples, e no mau sentido quando não é.

A tabela que importa

Critério	LangGraph	CrewAI	OpenAI Agents SDK
Linhas de código (agente de 3 etapas)	~120	~75	~60
Tempo até primeiro output	38 min	22 min	18 min
Controle de fluxo	Granular (grafo explícito)	Médio (process types)	Básico (handoffs)
Estado persistente	Nativo (checkpointer)	Via memória de crew	Não nativo
Suporte a MCP	Via integração manual	Nativo (v1.10+)	Parcial
Suporte a A2A	Não nativo	Nativo	Não nativo
Debugging	Bom (LangSmith)	Médio (logs verbosos)	Bom (tracing embutido)
Observabilidade	LangSmith/LangFuse	Integrações terceiras	Dashboard OpenAI
Vendor lock-in	Baixo	Baixo	Alto (OpenAI models)
GitHub Stars	~18K	~44.6K	~8K
Curva de aprendizado	Alta	Média	Baixa

Pydantic AI e AgentOps: o que mais importa

Menção rápida a dois pontos que vão influenciar sua decisão.

Pydantic AI (github.com/pydantic/pydantic-ai) não é um framework de agentes — é uma camada type-safe e async-first para interações com LLMs. Eu uso como building block dentro de agentes LangGraph: o grafo cuida do fluxo, Pydantic AI cuida do contrato de dados. Se você quer controle total do schema, vale o combo.

AgentOps é a disciplina que ninguém pensa no protótipo e todo mundo precisa em produção. Como monitoro decisões de agentes? Como debugo fluxos multi-step? Ferramentas como LangFuse, AgentOps.ai e Arize Phoenix estão preenchendo o gap. Minha recomendação: escolha a ferramenta de observabilidade antes de escolher o framework.

MCP e A2A estão acelerando isso. MCP padroniza como agentes acessam contexto externo. A2A padroniza como agentes conversam entre si. Ambos são agnósticos de framework — e quem adota primeiro (CrewAI, no momento) ganha vantagem prática.

Minha recomendação por caso de uso

“Preciso de controle total sobre um workflow complexo com estado.” LangGraph. Sem hesitar. Se o seu agente tem branching, loops, retry condicional e precisa de checkpointing, é a ferramenta certa. Paga-se o custo da complexidade com previsibilidade.

“Preciso prototipar rápido e validar com stakeholders.” CrewAI. O tempo de prototipagem 40% menor é real. A abstração role-based comunica bem para não-técnicos. E com MCP/A2A nativos, o protótipo tem mais chance de sobreviver à produção.

“Minha stack é 100% OpenAI e o caso é relativamente simples.” OpenAI Agents SDK. Menor fricção, menor boilerplate, tracing embutido. Mas saiba que está comprando lock-in junto.

“Quero type-safety e controle total do schema.” Pydantic AI, possivelmente combinado com LangGraph para orquestração.

Limitações desse comparativo

O agente do teste é simples de propósito — três etapas lineares. Em workflows com 10+ nós e branching dinâmico, as diferenças se amplificam a favor do LangGraph. O OpenAI Agents SDK é novo demais para ter battle-testing em produção pesada. E “linhas de código” é uma métrica imperfeita, mas para engenheiros avaliando tempo de implementação, é um proxy útil.

Veredito

Não existe framework perfeito — existe framework certo para o problema. Em março de 2026, o ecossistema de agentes está fragmentado da melhor forma possível: frameworks especializados para casos especializados. A pior decisão é ficar parado avaliando. A segunda pior é escolher por hype.

Clone o repo. Rode o agente. Meça. Decida.