Frameworks de IA Agentica Comparados: LangGraph vs CrewAI vs OpenAI Agents SDK vs Claude Agent SDK

Os agentes de IA passaram de demos de pesquisa para sistemas em producao. Espera-se que mais de 60% das aplicacoes de IA empresariais incluam componentes agentivos ate 2026. Mas construir agentes do zero - gerenciando loops de tool, estado, memoria, tratamento de erros e coordenacao multi-agente - e complexo. E ai que entram os frameworks.

Quatro frameworks dominam em 2026: LangGraph, CrewAI, OpenAI Agents SDK e Claude Agent SDK. Cada um adota uma abordagem fundamentalmente diferente para o mesmo problema: dar aos LLM a capacidade de raciocinar, planejar, usar tool e colaborar.

Visao Geral

LangGraph: O Construtor de Grafos

O LangGraph modela workflows de agentes como grafos ciclicos dirigidos. Voce define nos (funcoes que fazem o trabalho) e arestas (transicoes entre eles, opcionalmente condicionais). O estado flui pelo grafo e persiste via checkpointing.

Este e o framework mais explicito e controlavel - voce conecta cada passo manualmente.

Conceitos Chave

• StateGraph: a definicao do grafo com estado tipado
• Nodes: funcoes Python que transformam o estado
• Edges: conexoes entre nos, podem ser condicionais
• Checkpointing: persistencia integrada para workflows de longa duracao

Exemplo de Codigo

from langgraph.graph import StateGraph, MessagesState, START, END
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o")

def call_agent(state: MessagesState):
    response = llm.invoke(state["messages"])
    return {"messages": [response]}

def should_continue(state: MessagesState):
    last = state["messages"][-1]
    if last.tool_calls:
        return "tools"
    return END

def call_tools(state: MessagesState):
    # Execute tool calls and return results
    results = []
    for tool_call in state["messages"][-1].tool_calls:
        result = execute_tool(tool_call)
        results.append(result)
    return {"messages": results}

graph = StateGraph(MessagesState)
graph.add_node("agent", call_agent)
graph.add_node("tools", call_tools)
graph.add_edge(START, "agent")
graph.add_conditional_edges("agent", should_continue, {"tools": "tools", END: END})
graph.add_edge("tools", "agent")

app = graph.compile()
result = app.invoke({"messages": [{"role": "user", "content": "What's the weather?"}]})

Pontos Fortes

• Controle granular sobre cada passo e transicao
• Checkpointing integrado e human-in-the-loop
• Paridade completa com TypeScript
• Funciona com qualquer provedor LLM
• Ideal para workflows complexos com ramificacao condicional e loops

Pontos Fracos

• Curva de aprendizado ingreme - e preciso entender conceitos de teoria dos grafos
• Verboso para casos de uso simples - um agente basico requer mais boilerplate que outros frameworks
• O debugging de fluxos do grafo pode ser desafiador sem o LangSmith

Precos

Open-source (MIT). O LangSmith (plataforma de observabilidade gerenciada) tem planos pagos para monitoramento em producao.

CrewAI: O Montador de Equipes

O CrewAI usa uma metafora humana: voce monta um crew de agentes especializados, cada um com um papel, um objetivo e uma historia. Os agentes colaboram em tarefas usando tool, coordenados por um processo (sequencial, hierarquico ou consensual).

Pense nisso como contratar uma equipe onde cada membro tem um titulo e uma especialidade especificos.

Conceitos Chave

• Agent: um persona com papel, objetivo, historia e tool
• Task: uma atribuicao com descricao, saida esperada e agente designado
• Crew: um grupo de agentes trabalhando juntos
• Process: estrategia de execucao (sequencial, hierarquica, consensual)
• Flow: camada de orquestracao event-driven para conectar multiplos crews

Exemplo de Codigo

from crewai import Agent, Task, Crew, Process

researcher = Agent(
    role="Senior Research Analyst",
    goal="Find comprehensive data about the given topic",
    backstory="You have 10 years of experience in technology research. "
              "You are thorough and always verify facts from multiple sources.",
    tools=[web_search_tool],
    verbose=True,
)

writer = Agent(
    role="Technical Writer",
    goal="Create clear, engaging technical content",
    backstory="You write for a developer audience. "
              "Your articles are practical and include code examples.",
    tools=[file_tool],
    verbose=True,
)

research_task = Task(
    description="Research the latest developments in WebAssembly in 2026. "
                "Focus on WASI, Component Model, and production use cases.",
    expected_output="A structured research document with key findings and sources.",
    agent=researcher,
)

writing_task = Task(
    description="Write a blog post based on the research. "
                "Include code examples and Mermaid diagrams.",
    expected_output="A complete blog post in Markdown format.",
    agent=writer,
    context=[research_task],  # Writer receives researcher's output
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process=Process.sequential,
    verbose=True,
)

result = crew.kickoff()
print(result.raw)

Pontos Fortes

• Abstracao baseada em papeis intuitiva - facil de compreender
• Mais de 100 integracoes de tool incorporadas
• Memoria compartilhada entre agentes (curto prazo, longo prazo, por entidade)
• Maior comunidade (~40k estrelas GitHub)
• Processo hierarquico com um agente "manager" que delega e valida

Pontos Fracos

• Menos controle granular que o LangGraph - voce define papeis, nao caminhos de execucao exatos
• O processo hierarquico pode ser imprevisivel quando os agentes discordam
• O debugging de conversas multi-agente e mais dificil que fluxos de agente unico

Precos

Core open-source (gratuito). CrewAI Platform: $99/mes (Teams) ate $120k/ano (Enterprise). Precos baseados em crews ativos e execucoes mensais.

OpenAI Agents SDK: O Roteador

O OpenAI Agents SDK (sucessor espiritual do Swarm) foca em handoff - agentes que transferem conversas para outros agentes especializados. E o framework mais minimalista: agentes, tool, handoff e guardrail. So isso.

Conceitos Chave

• Agent: modelo + instrucoes + tool + handoff
• Handoff: uma transferencia para outro agente (modelada como um tool que o LLM pode chamar)
• Guardrail: validacao de entrada/saida que roda em paralelo com o agente
• Runner: executa o loop do agente
• Tracing: observabilidade integrada para todas as chamadas LLM, invocacoes de tool e handoff

Exemplo de Codigo

from agents import Agent, Runner, handoff, InputGuardrail, GuardrailFunctionOutput
from pydantic import BaseModel

class SafetyCheck(BaseModel):
    is_safe: bool
    reason: str

async def content_safety(ctx, agent, input_text):
    result = await Runner.run(
        Agent(name="Safety", instructions="Check if input is safe. No PII."),
        input_text,
        context=ctx,
    )
    output = SafetyCheck.model_validate_json(result.final_output)
    return GuardrailFunctionOutput(
        output_info=output, tripwire_triggered=not output.is_safe
    )

billing_agent = Agent(
    name="Billing Agent",
    instructions="You handle billing inquiries. Be precise with numbers.",
    tools=[lookup_invoice, process_payment],
)

refund_agent = Agent(
    name="Refund Agent",
    instructions="You process refund requests. Always verify the order first.",
    tools=[lookup_order, issue_refund],
)

triage_agent = Agent(
    name="Triage Agent",
    instructions="Route the customer to the right specialist. "
                 "Ask clarifying questions if needed.",
    handoffs=[billing_agent, refund_agent],
    input_guardrails=[InputGuardrail(guardrail_function=content_safety)],
)

result = await Runner.run(triage_agent, "I need a refund for order #4521")
print(result.final_output)
# The triage agent routes to refund_agent, which processes the refund

Pontos Fortes

• Padrao de handoff limpo - natural para workflows de routing/triage
• Os guardrail rodam em paralelo com a execucao (fail-fast, nao bloqueantes)
• Dashboard de tracing integrado para debugging
• Apesar do nome, suporta modelos nao-OpenAI
• Abstracao minima - facil de entender e estender

Pontos Fracos

• Gerenciamento de estado menos maduro que o LangGraph
• Sem persistencia ou checkpointing integrados
• O ecossistema de tool de terceiros e mais limitado
• O design centrado em handoff pode nao se adequar a toda arquitetura

Precos

Open-source (MIT). Voce paga por token conforme o modelo utilizado.

Claude Agent SDK: O Desenvolvedor

O Claude Agent SDK adota uma abordagem diferente: em vez de definir workflows ou papeis, voce da ao agente um conjunto de tool e o deixa descobrir como realizar a tarefa. Ele usa o mesmo loop autonomo que alimenta o Claude Code - ler, agir, verificar, iterar.

Conceitos Chave

• query(): o ponto de entrada principal que inicia o loop do agente
• Tool integrados: Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch
• Tool personalizados via MCP: defina tool como servidores MCP in-process
• Sub-agents: agentes especializados para os quais o pai pode delegar
• Sessions: mantem o contexto entre multiplas interacoes

Exemplo de Codigo

import { tool, createSdkMcpServer, query } from "@anthropic-ai/claude-agent-sdk";
import { z } from "zod";

const searchDocs = tool(
  "search_docs",
  "Search the internal documentation for relevant information",
  { query: z.string().describe("Search query") },
  async ({ query }) => {
    const results = await vectorStore.similaritySearch(query, 5);
    return {
      content: [{ type: "text", text: results.map(r => r.pageContent).join("\n\n") }],
    };
  }
);

const docsServer = createSdkMcpServer({
  name: "docs",
  version: "1.0.0",
  tools: [searchDocs],
});

for await (const message of query({
  prompt: "Find how authentication works in our system and write a summary",
  options: {
    mcpServers: { docs: docsServer },
    allowedTools: ["Read", "Glob", "Grep", "mcp__docs__search_docs"],
  },
})) {
  if (message.type === "result" && message.subtype === "success") {
    console.log(message.result);
  }
}

Pontos Fortes

• Integracao MCP de primeira classe - conecte-se a qualquer ecossistema de servidores MCP
• Tool integrados para operacoes de arquivo, terminal e acesso web
• Compactacao automatica de contexto para bases de codigo grandes
• Paralelismo de sub-agents para tarefas complexas
• Mesmo motor do Claude Code - testado em batalha em workflows de desenvolvimento reais

Pontos Fracos

• Apenas modelos Claude - sem suporte multi-provedor
• Framework mais recente com uma comunidade menor
• Requer o runtime Node.js mesmo para o SDK Python
• Menos controle explicito do workflow comparado ao LangGraph

Precos

Open-source. Tarifas padrao por token da API do Claude. Managed Agents (versao hospedada): $0.08 por hora de sessao alem dos custos por token.

Quando Escolher Qual

Escolha LangGraph se:

• Voce precisa de controle preciso sobre cada passo do workflow
• Seu caso de uso envolve logica condicional complexa e loops
• Voce quer persistencia integrada e checkpoints human-in-the-loop
• Voce precisa usar multiplos provedores LLM no mesmo workflow

Escolha CrewAI se:

• Voce quer uma abstracao intuitiva baseada em papeis
• Sua tarefa envolve multiplos agentes com especialidades distintas
• Voce precisa que os agentes colaborem e passem contexto entre si
• Voce valoriza a maior comunidade e o maior numero de integracoes

Escolha OpenAI Agents SDK se:

• Seu padrao principal e rotear conversas para especialistas
• Voce precisa de guardrail que validem entrada/saida em paralelo
• Voce quer a abstracao mais simples possivel com boilerplate minimo
• Tracing e observabilidade integrados sao importantes

Escolha Claude Agent SDK se:

• Seus agentes precisam ler, escrever e executar codigo
• Voce quer integracao de primeira classe com servidores MCP
• Voce precisa de agentes autonomos que iteram e se auto-corrigem
• Voce ja usa Claude e quer a integracao mais profunda

E Possivel Combinar os Frameworks?

Sim. Um padrao comum e usar um framework para orquestracao e outro para os agentes individuais:

• LangGraph para o grafo do workflow geral
• CrewAI para um no especifico que requer colaboracao multi-agente
• Claude Agent SDK para sub-tarefas relacionadas a coding via MCP
• OpenAI Agents SDK para triage e routing voltado ao cliente

Os frameworks nao sao mutuamente exclusivos. Use o que se encaixa em cada parte do seu sistema.

Conclusao

Cada framework faz uma aposta clara:

• LangGraph otimiza para o controle - voce decide cada transicao
• CrewAI otimiza para a colaboracao - os agentes trabalham em equipe
• OpenAI Agents SDK otimiza para a simplicidade - abstracao minima, handoff limpos
• Claude Agent SDK otimiza para a autonomia - de os tool e deixe-o trabalhar

A escolha certa depende do seu workflow, da sua equipe e do seu stack existente. Escolha o que corresponde ao seu caso de uso principal, aprenda-o bem e incorpore os outros quando chegar ao ponto forte deles.