1~
2Os 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.
3~
4Quatro 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.
5~
6## Visao Geral
7~
8| Aspecto | LangGraph | CrewAI | OpenAI Agents SDK | Claude Agent SDK |
9|--------|-----------|--------|-------------------|-----------------|
10| **Criado por** | LangChain | CrewAI Inc. | OpenAI | Anthropic |
11| **Arquitetura** | Baseada em grafos | Baseada em papeis | Baseada em handoff | Loop autonomo |
12| **Filosofia** | Controle maximo | Colaboracao de equipe | Abstracao minima | De um computador ao agente |
13| **Linguagens** | Python, TypeScript | Python | Python | Python, TypeScript |
14| **Suporte a modelos** | Qualquer (OpenAI, Claude, local) | Qualquer | Qualquer (apesar do nome) | Apenas Claude |
15| **Estrelas GitHub** | ~29k | ~40k | ~21k | ~6k |
16| **Ideal para** | Workflows stateful complexos | Especializacao multi-agente | Routing e triage | Coding e tarefas com arquivos |
17~
18## LangGraph: O Construtor de Grafos
19~
20O 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.
21~
22Este e o framework mais explicito e controlavel  -  voce conecta cada passo manualmente.
23~
24```mermaid
25graph LR
26    Start --> Router[Router Node]
27    Router -->|needs research| Research[Research Node]
28    Router -->|needs code| Code[Code Node]
29    Research --> Synthesize[Synthesize Node]
30    Code --> Synthesize
31    Synthesize --> End
32```
33~
34### Conceitos Chave
35~
36- **StateGraph**: a definicao do grafo com estado tipado
37- **Nodes**: funcoes Python que transformam o estado
38- **Edges**: conexoes entre nos, podem ser condicionais
39- **Checkpointing**: persistencia integrada para workflows de longa duracao
40~
41### Exemplo de Codigo
42~
43```python
44from langgraph.graph import StateGraph, MessagesState, START, END
45from langchain_openai import ChatOpenAI
46~
47llm = ChatOpenAI(model="gpt-4o")
48~
49def call_agent(state: MessagesState):
50    response = llm.invoke(state["messages"])
51    return {"messages": [response]}
52~
53def should_continue(state: MessagesState):
54    last = state["messages"][-1]
55    if last.tool_calls:
56        return "tools"
57    return END
58~
59def call_tools(state: MessagesState):
60    # Execute tool calls and return results
61    results = []
62    for tool_call in state["messages"][-1].tool_calls:
63        result = execute_tool(tool_call)
64        results.append(result)
65    return {"messages": results}
66~
67graph = StateGraph(MessagesState)
68graph.add_node("agent", call_agent)
69graph.add_node("tools", call_tools)
70graph.add_edge(START, "agent")
71graph.add_conditional_edges("agent", should_continue, {"tools": "tools", END: END})
72graph.add_edge("tools", "agent")
73~
74app = graph.compile()
75result = app.invoke({"messages": [{"role": "user", "content": "What's the weather?"}]})
76```
77~
78### Pontos Fortes
79~
80- Controle granular sobre cada passo e transicao
81- Checkpointing integrado e human-in-the-loop
82- Paridade completa com TypeScript
83- Funciona com qualquer provedor LLM
84- Ideal para workflows complexos com ramificacao condicional e loops
85~
86### Pontos Fracos
87~
88- Curva de aprendizado ingreme  -  e preciso entender conceitos de teoria dos grafos
89- Verboso para casos de uso simples  -  um agente basico requer mais boilerplate que outros frameworks
90- O debugging de fluxos do grafo pode ser desafiador sem o LangSmith
91~
92### Precos
93~
94Open-source (MIT). O LangSmith (plataforma de observabilidade gerenciada) tem planos pagos para monitoramento em producao.
95~
96## CrewAI: O Montador de Equipes
97~
98O 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).
99~
100Pense nisso como contratar uma equipe onde cada membro tem um titulo e uma especialidade especificos.
101~
102```mermaid
103graph TD
104    Crew[Crew Manager] --> R[Researcher\nRole: Find data\nTools: WebSearch]
105    Crew --> W[Writer\nRole: Write content\nTools: FileWrite]
106    Crew --> E[Editor\nRole: Review quality\nTools: FileRead]
107    R --> Task1[Research Task]
108    W --> Task2[Writing Task]
109    E --> Task3[Review Task]
110    Task1 --> Task2 --> Task3
111```
112~
113### Conceitos Chave
114~
115- **Agent**: um persona com papel, objetivo, historia e tool
116- **Task**: uma atribuicao com descricao, saida esperada e agente designado
117- **Crew**: um grupo de agentes trabalhando juntos
118- **Process**: estrategia de execucao (sequencial, hierarquica, consensual)
119- **Flow**: camada de orquestracao event-driven para conectar multiplos crews
120~
121### Exemplo de Codigo
122~
123```python
124from crewai import Agent, Task, Crew, Process
125~
126researcher = Agent(
127    role="Senior Research Analyst",
128    goal="Find comprehensive data about the given topic",
129    backstory="You have 10 years of experience in technology research. "
130              "You are thorough and always verify facts from multiple sources.",
131    tools=[web_search_tool],
132    verbose=True,
133)
134~
135writer = Agent(
136    role="Technical Writer",
137    goal="Create clear, engaging technical content",
138    backstory="You write for a developer audience. "
139              "Your articles are practical and include code examples.",
140    tools=[file_tool],
141    verbose=True,
142)
143~
144research_task = Task(
145    description="Research the latest developments in WebAssembly in 2026. "
146                "Focus on WASI, Component Model, and production use cases.",
147    expected_output="A structured research document with key findings and sources.",
148    agent=researcher,
149)
150~
151writing_task = Task(
152    description="Write a blog post based on the research. "
153                "Include code examples and Mermaid diagrams.",
154    expected_output="A complete blog post in Markdown format.",
155    agent=writer,
156    context=[research_task],  # Writer receives researcher's output
157)
158~
159crew = Crew(
160    agents=[researcher, writer],
161    tasks=[research_task, writing_task],
162    process=Process.sequential,
163    verbose=True,
164)
165~
166result = crew.kickoff()
167print(result.raw)
168```
169~
170### Pontos Fortes
171~
172- Abstracao baseada em papeis intuitiva  -  facil de compreender
173- Mais de 100 integracoes de tool incorporadas
174- Memoria compartilhada entre agentes (curto prazo, longo prazo, por entidade)
175- Maior comunidade (~40k estrelas GitHub)
176- Processo hierarquico com um agente "manager" que delega e valida
177~
178### Pontos Fracos
179~
180- Menos controle granular que o LangGraph  -  voce define papeis, nao caminhos de execucao exatos
181- O processo hierarquico pode ser imprevisivel quando os agentes discordam
182- O debugging de conversas multi-agente e mais dificil que fluxos de agente unico
183~
184### Precos
185~
186Core open-source (gratuito). CrewAI Platform: $99/mes (Teams) ate $120k/ano (Enterprise). Precos baseados em crews ativos e execucoes mensais.
187~
188## OpenAI Agents SDK: O Roteador
189~
190O 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.
191~
192```mermaid
193graph LR
194    User --> Triage[Triage Agent]
195    Triage -->|billing question| Billing[Billing Agent]
196    Triage -->|refund request| Refund[Refund Agent]
197    Triage -->|technical issue| Support[Support Agent]
198    Billing --> Response[Response]
199    Refund --> Response
200    Support --> Response
201```
202~
203### Conceitos Chave
204~
205- **Agent**: modelo + instrucoes + tool + handoff
206- **Handoff**: uma transferencia para outro agente (modelada como um tool que o LLM pode chamar)
207- **Guardrail**: validacao de entrada/saida que roda em paralelo com o agente
208- **Runner**: executa o loop do agente
209- **Tracing**: observabilidade integrada para todas as chamadas LLM, invocacoes de tool e handoff
210~
211### Exemplo de Codigo
212~
213```python
214from agents import Agent, Runner, handoff, InputGuardrail, GuardrailFunctionOutput
215from pydantic import BaseModel
216~
217class SafetyCheck(BaseModel):
218    is_safe: bool
219    reason: str
220~
221async def content_safety(ctx, agent, input_text):
222    result = await Runner.run(
223        Agent(name="Safety", instructions="Check if input is safe. No PII."),
224        input_text,
225        context=ctx,
226    )
227    output = SafetyCheck.model_validate_json(result.final_output)
228    return GuardrailFunctionOutput(
229        output_info=output, tripwire_triggered=not output.is_safe
230    )
231~
232billing_agent = Agent(
233    name="Billing Agent",
234    instructions="You handle billing inquiries. Be precise with numbers.",
235    tools=[lookup_invoice, process_payment],
236)
237~
238refund_agent = Agent(
239    name="Refund Agent",
240    instructions="You process refund requests. Always verify the order first.",
241    tools=[lookup_order, issue_refund],
242)
243~
244triage_agent = Agent(
245    name="Triage Agent",
246    instructions="Route the customer to the right specialist. "
247                 "Ask clarifying questions if needed.",
248    handoffs=[billing_agent, refund_agent],
249    input_guardrails=[InputGuardrail(guardrail_function=content_safety)],
250)
251~
252result = await Runner.run(triage_agent, "I need a refund for order #4521")
253print(result.final_output)
254# The triage agent routes to refund_agent, which processes the refund
255```
256~
257### Pontos Fortes
258~
259- Padrao de handoff limpo  -  natural para workflows de routing/triage
260- Os guardrail rodam em paralelo com a execucao (fail-fast, nao bloqueantes)
261- Dashboard de tracing integrado para debugging
262- Apesar do nome, suporta modelos nao-OpenAI
263- Abstracao minima  -  facil de entender e estender
264~
265### Pontos Fracos
266~
267- Gerenciamento de estado menos maduro que o LangGraph
268- Sem persistencia ou checkpointing integrados
269- O ecossistema de tool de terceiros e mais limitado
270- O design centrado em handoff pode nao se adequar a toda arquitetura
271~
272### Precos
273~
274Open-source (MIT). Voce paga por token conforme o modelo utilizado.
275~
276## Claude Agent SDK: O Desenvolvedor
277~
278O 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.
279~
280```mermaid
281graph TD
282    Prompt[User Prompt] --> Loop[Autonomous Agent Loop]
283    Loop --> Reason[Reason about next step]
284    Reason --> Act[Execute tool]
285    Act --> Verify[Check result]
286    Verify -->|not done| Loop
287    Verify -->|done| Output[Final output]
288```
289~
290### Conceitos Chave
291~
292- **query()**: o ponto de entrada principal que inicia o loop do agente
293- **Tool integrados**: Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch
294- **Tool personalizados via MCP**: defina tool como servidores MCP in-process
295- **Sub-agents**: agentes especializados para os quais o pai pode delegar
296- **Sessions**: mantem o contexto entre multiplas interacoes
297~
298### Exemplo de Codigo
299~
300```typescript
301import { tool, createSdkMcpServer, query } from "@anthropic-ai/claude-agent-sdk";
302import { z } from "zod";
303~
304const searchDocs = tool(
305  "search_docs",
306  "Search the internal documentation for relevant information",
307  { query: z.string().describe("Search query") },
308  async ({ query }) => {
309    const results = await vectorStore.similaritySearch(query, 5);
310    return {
311      content: [{ type: "text", text: results.map(r => r.pageContent).join("\n\n") }],
312    };
313  }
314);
315~
316const docsServer = createSdkMcpServer({
317  name: "docs",
318  version: "1.0.0",
319  tools: [searchDocs],
320});
321~
322for await (const message of query({
323  prompt: "Find how authentication works in our system and write a summary",
324  options: {
325    mcpServers: { docs: docsServer },
326    allowedTools: ["Read", "Glob", "Grep", "mcp__docs__search_docs"],
327  },
328})) {
329  if (message.type === "result" && message.subtype === "success") {
330    console.log(message.result);
331  }
332}
333```
334~
335### Pontos Fortes
336~
337- Integracao MCP de primeira classe  -  conecte-se a qualquer ecossistema de servidores MCP
338- Tool integrados para operacoes de arquivo, terminal e acesso web
339- Compactacao automatica de contexto para bases de codigo grandes
340- Paralelismo de sub-agents para tarefas complexas
341- Mesmo motor do Claude Code  -  testado em batalha em workflows de desenvolvimento reais
342~
343### Pontos Fracos
344~
345- Apenas modelos Claude  -  sem suporte multi-provedor
346- Framework mais recente com uma comunidade menor
347- Requer o runtime Node.js mesmo para o SDK Python
348- Menos controle explicito do workflow comparado ao LangGraph
349~
350### Precos
351~
352Open-source. Tarifas padrao por token da API do Claude. Managed Agents (versao hospedada): $0.08 por hora de sessao alem dos custos por token.
353~
354## Quando Escolher Qual
355~
356```mermaid
357graph TD
358    Start{What's your priority?}
359    Start -->|Full control over workflow| LG[LangGraph]
360    Start -->|Multi-agent collaboration| CA[CrewAI]
361    Start -->|Routing and triage| OA[OpenAI Agents SDK]
362    Start -->|Coding and file automation| CS[Claude Agent SDK]
363~
364    LG --> LGU[Complex stateful workflows\nConditional branching\nHuman-in-the-loop]
365    CA --> CAU[Team of specialized agents\nResearch + writing pipelines\nContent generation]
366    OA --> OAU[Customer service routing\nMulti-step handoffs\nInput validation]
367    CS --> CSU[Code generation and review\nFile-heavy automation\nMCP tool ecosystem]
368```
369~
370### Escolha LangGraph se:
371- Voce precisa de controle preciso sobre cada passo do workflow
372- Seu caso de uso envolve logica condicional complexa e loops
373- Voce quer persistencia integrada e checkpoints human-in-the-loop
374- Voce precisa usar multiplos provedores LLM no mesmo workflow
375~
376### Escolha CrewAI se:
377- Voce quer uma abstracao intuitiva baseada em papeis
378- Sua tarefa envolve multiplos agentes com especialidades distintas
379- Voce precisa que os agentes colaborem e passem contexto entre si
380- Voce valoriza a maior comunidade e o maior numero de integracoes
381~
382### Escolha OpenAI Agents SDK se:
383- Seu padrao principal e rotear conversas para especialistas
384- Voce precisa de guardrail que validem entrada/saida em paralelo
385- Voce quer a abstracao mais simples possivel com boilerplate minimo
386- Tracing e observabilidade integrados sao importantes
387~
388### Escolha Claude Agent SDK se:
389- Seus agentes precisam ler, escrever e executar codigo
390- Voce quer integracao de primeira classe com servidores MCP
391- Voce precisa de agentes autonomos que iteram e se auto-corrigem
392- Voce ja usa Claude e quer a integracao mais profunda
393~
394## E Possivel Combinar os Frameworks?
395~
396Sim. Um padrao comum e usar um framework para orquestracao e outro para os agentes individuais:
397~
398- **LangGraph** para o grafo do workflow geral
399- **CrewAI** para um no especifico que requer colaboracao multi-agente
400- **Claude Agent SDK** para sub-tarefas relacionadas a coding via MCP
401- **OpenAI Agents SDK** para triage e routing voltado ao cliente
402~
403Os frameworks nao sao mutuamente exclusivos. Use o que se encaixa em cada parte do seu sistema.
404~
405## Conclusao
406~
407Cada framework faz uma aposta clara:
408~
409- **LangGraph** otimiza para o controle  -  voce decide cada transicao
410- **CrewAI** otimiza para a colaboracao  -  os agentes trabalham em equipe
411- **OpenAI Agents SDK** otimiza para a simplicidade  -  abstracao minima, handoff limpos
412- **Claude Agent SDK** otimiza para a autonomia  -  de os tool e deixe-o trabalhar
413~
414A 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.
415~