OpenAI Agents SDK vs Google ADK vs LangGraph em 2026: O confronto definitivo

A guerra dos frameworks pra agentes AI em 2026 tem três protagonistas claros: OpenAI Agents SDK, Google ADK e LangGraph. Cada um representa uma aposta radicalmente diferente em como sistemas de IA autônomos devem ser construídos.

Há seis meses, quem construía agentes tinha duas opções: LangGraph pra produção séria, ou costurar chamadas de API na mão. Esse cenário acabou. OpenAI lançou um framework completo. Google soltou o ADK com integração profunda com Vertex AI. E o LangGraph bateu 1.0 GA, consolidando a abordagem baseada em grafos como production-ready.

O problema? Todos dizem ser "o mais fácil" e "o mais pronto pra produção." Os blogs das empresas são basicamente material de marketing. O que dev precisa de verdade é comparação técnica sem enrolação — o que cada um faz bem, onde falha, e qual se encaixa no seu caso.

É exatamente isso que esse artigo faz. Sem favoritismo, sem esconder limitações. Vamos comparar arquitetura, integração de ferramentas, memória, padrões multi-agente e maturidade pra produção com código real. No final você vai saber que framework usar — e quando evitar.

Arquitetura: Três filosofias

Os três frameworks não são implementações diferentes da mesma ideia. Representam três visões distintas de como sistemas de agentes devem funcionar.

OpenAI Agents SDK: Minimalismo deliberado

O approach do OpenAI é intencionalmente mínimo. O framework inteiro se resume a quatro primitivas: Agents, Handoffs, Guardrails e Tools. Sem grafos, sem motor de orquestração elaborado, sem máquinas de estado.

from agents import Agent, Runner

agent = Agent(
    name="research_assistant",
    instructions="You are a helpful research assistant. Find accurate, up-to-date information.",
    model="gpt-4.1",
    tools=[web_search, file_reader],
)

result = await Runner.run(agent, "What are the latest developments in quantum computing?")
print(result.final_output)

A filosofia é clara: construir agentes não deveria exigir PhD em sistemas distribuídos. Define um agente com instruções e ferramentas, executa e pega o resultado. O loop agêntico (chamar modelo, executar ferramentas, retroalimentar resultados) o SDK gerencia internamente.

Ponto interessante: apesar de ser do OpenAI, o SDK é agnóstico de modelo. Suporta mais de 100 modelos não-OpenAI pela Chat Completions API. Dá pra plugar Claude, Gemini, Mistral ou qualquer modelo local.

Google ADK: Engenharia de software encontra IA

O Agent Development Kit do Google toma uma posição muito diferente. O ADK trata agentes como componentes de software — modulares, testáveis, componíveis.

from google.adk.agents import Agent
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService

root_agent = Agent(
    name="coordinator",
    model="gemini-2.5-pro",
    description="Coordinates research and analysis tasks",
    instruction="You coordinate research tasks. Delegate to specialists when needed.",
    sub_agents=[research_agent, analysis_agent],
    tools=[web_search_tool],
)

session_service = InMemorySessionService()
runner = Runner(agent=root_agent, app_name="research_app", session_service=session_service)

session = await session_service.create_session(app_name="research_app", user_id="user_1")

response = await runner.run_async(
    user_id="user_1",
    session_id=session.id,
    new_message=Content(role="user", parts=[Part(text="Analyze the AI agent framework market")])
)

Repara na gestão explícita de sessões, a estrutura hierárquica de agentes e o padrão runner. ADK quer que você pense em agentes do mesmo jeito que pensa em microserviços — limites claros, estado explícito, arquitetura componível.

A killer feature: suporte multimodal nativo. Agentes ADK processam texto, imagens, vídeo e áudio no mesmo workflow. E a integração profunda com Google Cloud (Vertex AI, Cloud Run, Agent Engine) dá deployment gerenciado de cara.

LangGraph: A máquina de estados

LangGraph modela workflows de agentes como grafos dirigidos com estado persistente. Cada ponto de decisão é um nó, cada transição é uma aresta, e o fluxo inteiro de execução é explícito e inspecionável.

from langgraph.graph import StateGraph, MessagesState, START, END
from langgraph.prebuilt import ToolNode

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

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

workflow = StateGraph(MessagesState)
workflow.add_node("agent", call_model)
workflow.add_node("tools", ToolNode(tools=[web_search, calculator]))

workflow.add_edge(START, "agent")
workflow.add_conditional_edges("agent", should_continue, ["tools", END])
workflow.add_edge("tools", "agent")

app = workflow.compile()
result = await app.ainvoke({"messages": [("user", "What's 2+2 and then search for that number")]})

É o mais verboso dos três, mas essa verbosidade compra algo crucial: controle total sobre o fluxo de execução. Você vê exatamente que nó roda quando, pode adicionar branching condicional, implementar loops, botar checkpoints human-in-the-loop e debuggar o fluxo inteiro com time-travel.

LangGraph é pra devs que não confiam em caixa preta.

Matriz filosófica

Integração de ferramentas: O que separa agente de chatbot

Ferramentas são o que separa agente AI de chatbot. Como cada framework maneja definição, execução e recuperação de erro de ferramentas diz muito sobre a maturidade pra produção.

OpenAI Agents SDK: Três tipos

O SDK oferece três categorias:

1. Ferramentas hosteadas — Gerenciadas pelo OpenAI:

from agents import Agent, WebSearchTool, CodeInterpreterTool

agent = Agent(
    name="analyst",
    instructions="You analyze data and search the web for context.",
    tools=[WebSearchTool(), CodeInterpreterTool()],
)

2. Function tools — Código custom:

from agents import function_tool

@function_tool
def get_stock_price(symbol: str) -> dict:
    """Fetch real-time stock price for a given ticker symbol."""
    response = requests.get(f"https://api.stocks.com/v1/price/{symbol}")
    return response.json()

3. MCP tools — Model Context Protocol:

from agents.mcp import MCPServerStdio

async with MCPServerStdio(
    command="npx",
    args=["-y", "@modelcontextprotocol/server-filesystem", "/path/to/data"]
) as server:
    tools = await server.list_tools()
    agent = Agent(name="file_agent", tools=tools)

A integração MCP é destaque. MCP tá se consolidando como protocolo universal pra conectar modelos AI a ferramentas externas, e o suporte first-class do OpenAI conecta a qualquer servidor MCP.

Google ADK: Composabilidade nativa

ADK organiza ferramentas por categorias com foco em composabilidade e compartilhamento de contexto:

from google.adk.tools import FunctionTool, google_search

def analyze_sentiment(text: str) -> dict:
    """Analyze the sentiment of the given text."""
    return {"sentiment": "positive", "confidence": 0.87}

sentiment_tool = FunctionTool(func=analyze_sentiment)

agent = Agent(
    name="market_analyst",
    model="gemini-2.5-pro",
    instruction="Analyze market sentiment using web data and text analysis.",
    tools=[sentiment_tool, google_search],
)

Killer feature do ADK: agentes como ferramentas:

research_agent = Agent(name="researcher", model="gemini-2.5-flash", instruction="You research topics thoroughly.", tools=[google_search])

coordinator = Agent(
    name="coordinator",
    model="gemini-2.5-pro",
    instruction="Coordinate research and analysis.",
    tools=[research_agent.as_tool()],  # Agente vira ferramenta
)

Esse padrão agente-como-ferramenta é muito forte pra sistemas hierárquicos onde agentes especializados servem como capacidades pra orquestradores de nível acima.

LangGraph: Controle máximo

LangGraph dá o controle mais granular sobre execução de ferramentas:

from langchain_core.tools import tool
from langgraph.prebuilt import ToolNode

@tool
def web_search(query: str) -> str:
    """Search the web for information."""
    return search_results

@tool
def database_query(sql: str) -> str:
    """Execute a SQL query against the analytics database."""
    return results

tool_node = ToolNode(tools=[web_search, database_query])

def route_tools(state):
    last_message = state["messages"][-1]
    if not last_message.tool_calls:
        return END
    
    sensitive_tools = {"database_query"}
    called_tools = {tc["name"] for tc in last_message.tool_calls}
    
    if called_tools & sensitive_tools:
        return "human_approval"  # Rota pra aprovação humana
    return "tools"

Diferença fundamental: LangGraph nunca esconde execução de ferramentas atrás de abstrações. Cada tool call aparece no grafo, dá pra rotear ferramentas diferentes pra nós diferentes, e inserir passos de aprovação ou recovery de erro onde quiser.

Comparação de ferramentas

Memória e estado: O problema da persistência

Agente sem memória é só chamada de API sofisticada. Como cada framework lida com contexto de curto prazo, memória de longo prazo e persistência de estado define se seu agente aguenta conversas de verdade.

OpenAI Agents SDK: Variáveis de contexto

from agents import Agent, RunContextWrapper

@function_tool
async def save_preference(wrapper: RunContextWrapper[dict], key: str, value: str):
    """Save a user preference."""
    wrapper.context[key] = value
    return f"Saved {key} = {value}"

agent = Agent(
    name="assistant",
    instructions="You remember user preferences across the conversation.",
    tools=[save_preference, get_preference],
)

result = await Runner.run(agent, "My favorite color is blue", context={"user_id": "123"})

Pra persistência entre sessões tem SQLiteSession e backends similares. Simples, mas não tão sofisticado quanto sistemas de memória dedicados.

Google ADK: Arquitetura baseada em sessões

ADK tem o modelo de memória mais estruturado dos três:

from google.adk.sessions import DatabaseSessionService

session_service = DatabaseSessionService(connection_string="postgresql://...")

session = await session_service.create_session(
    app_name="my_agent",
    user_id="user_123",
    state={"preferences": {}, "conversation_history": [], "long_term_facts": []},
)

ADK separa memória de curto prazo (estado de sessão) de longo prazo (serviços plugáveis). Sessão tá embutida no framework — toda interação acontece dentro de uma sessão, que pode ser persistida, retomada e compartilhada entre agentes.

LangGraph: Checkpointing e time travel

O modelo de memória do LangGraph é o mais poderoso — e mais complexo:

from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver

async with AsyncPostgresSaver.from_conn_string("postgresql://...") as checkpointer:
    app = workflow.compile(checkpointer=checkpointer)
    config = {"configurable": {"thread_id": "conversation_123"}}
    
    result = await app.ainvoke({"messages": [("user", "Research AI frameworks")]}, config=config)
    
    # Time travel — navega pelo histórico completo
    history = [state async for state in app.aget_state_history(config)]
    previous_state = history[2]
    await app.aupdate_state(config, previous_state.values)

O sistema de checkpointing grava cada transição de estado: time-travel debugging, human-in-the-loop em qualquer ponto, retomada de workflows longos e bifurcação de qualquer checkpoint.

Comparação de memória

Orquestração multi-agente: Onde a complexidade mora

Agente único é fácil. O desafio real é coordenar múltiplos agentes com capacidades diferentes. É aqui que as diferenças entre frameworks ficam mais evidentes.

OpenAI: Handoffs (delegação)

O padrão multi-agente do SDK são os handoffs — um agente transfere controle pro outro:

from agents import Agent, handoff

triage_agent = Agent(
    name="triage",
    instructions="""You triage incoming requests.
    - For billing questions, hand off to the billing specialist.
    - For technical issues, hand off to the tech support agent.
    - For general questions, answer directly.""",
    handoffs=[
        handoff(billing_agent),
        handoff(tech_support_agent),
    ],
)

billing_agent = Agent(
    name="billing_specialist",
    instructions="You handle billing inquiries. Access account data as needed.",
    tools=[get_account_info, process_refund],
    handoffs=[handoff(triage_agent)],  # Pode devolver o controle
)

tech_support_agent = Agent(
    name="tech_support",
    instructions="You resolve technical issues. Escalate complex cases.",
    tools=[check_system_status, create_ticket],
    handoffs=[handoff(triage_agent)],
)

result = await Runner.run(triage_agent, "I was charged twice for my subscription")

Handoffs são elegantes pra fluxos de suporte, triage e routing onde o "especialista certo" deve atender a consulta. O modelo decide quando transferir com base nas instruções.

Limitação: handoffs são essencialmente delegação, não orquestração paralela. Não é simples rodar múltiplos agentes simultaneamente e juntar os resultados.

Google ADK: Equipes hierárquicas

ADK suporta múltiplos padrões de orquestração nativamente:

from google.adk.agents import Agent, SequentialAgent, ParallelAgent

researcher = Agent(
    name="researcher",
    model="gemini-2.5-flash",
    instruction="Research the given topic thoroughly.",
    tools=[google_search],
)

writer = Agent(
    name="writer",
    model="gemini-2.5-pro",
    instruction="Write a comprehensive report based on the research.",
)

reviewer = Agent(
    name="reviewer",
    model="gemini-2.5-pro",
    instruction="Review the report for accuracy and completeness.",
)

# Pipeline sequencial: pesquisar → escrever → revisar
pipeline = SequentialAgent(
    name="report_pipeline",
    sub_agents=[researcher, writer, reviewer],
)

# Ou execução paralela com merge de resultados
parallel_research = ParallelAgent(
    name="parallel_research",
    sub_agents=[web_researcher, academic_researcher, news_researcher],
)

ADK também tem LoopAgent pra refinamento iterativo:

from google.adk.agents import LoopAgent

refinement_loop = LoopAgent(
    name="refinement",
    sub_agents=[draft_agent, critique_agent, revise_agent],
    max_iterations=3,
)

Sequential, Parallel e Loop cobrem 90% dos workflows multi-agente sem código custom de orquestração.

LangGraph: Orquestração baseada em grafos

LangGraph lida com sistemas multi-agente como subgrafos dentro de um grafo maior:

from langgraph.graph import StateGraph, MessagesState

research_graph = create_research_subgraph()
analysis_graph = create_analysis_subgraph()
writing_graph = create_writing_subgraph()

def supervisor(state: MessagesState):
    response = supervisor_model.invoke([
        SystemMessage(content="Route to the appropriate specialist."),
        *state["messages"]
    ])
    return {"next_agent": response.content}

main = StateGraph(MessagesState)
main.add_node("supervisor", supervisor)
main.add_node("researcher", research_graph)
main.add_node("analyst", analysis_graph)
main.add_node("writer", writing_graph)

main.add_conditional_edges("supervisor", route_to_agent)
main.add_edge("researcher", "supervisor")
main.add_edge("analyst", "supervisor")
main.add_edge("writer", "supervisor")

Máxima flexibilidade mas máximo código. Você projeta o fluxo exato, decide quando os agentes rodam em sequência ou paralelo, e trata cada edge case explicitamente.

O padrão supervisor (um LLM decide qual agente roda) e o padrão hierárquico (agentes organizados em times com líderes) são bem documentados e testados em produção.

Comparação multi-agente

Produção: O que realmente importa

Comparações de framework adoram mostrar exemplos "hello world." Produção é diferente. Vamos ver o que cada framework oferece quando as coisas dão errado — porque em produção, sempre dão errado.

Observabilidade e tracing

OpenAI Agents SDK vem com tracing embutido:

from agents import trace

with trace("customer_support_flow"):
    result = await Runner.run(triage_agent, user_message)
    # Cada chamada LLM, execução de ferramenta e handoff fica traceado
    # Visível no dashboard OpenAI ou exportável pro seu stack de observabilidade

Google ADK integra com observabilidade do Google Cloud:

from google.adk.evaluation import evaluate_agent

eval_results = await evaluate_agent(
    agent=my_agent,
    test_cases=test_suite,
    metrics=["accuracy", "latency", "tool_usage"],
)

LangGraph usa LangSmith pra observabilidade profunda:

# Cada execução do grafo é automaticamente traceada no LangSmith
# Veja execução nó por nó, transições de estado, uso de tokens
# Time-travel pra qualquer ponto de qualquer execução

Guardrails e segurança

OpenAI Agents SDK tem guardrails de primeira classe:

from agents import Guardrail, GuardrailFunctionOutput, Agent

@input_guardrail
async def check_for_pii(ctx, agent, input_text):
    """Bloquear requests com informação pessoal."""
    result = await Runner.run(pii_detector_agent, input_text)
    if result.contains_pii:
        return GuardrailFunctionOutput(
            output_info={"blocked": True},
            tripwire_triggered=True,
        )

agent = Agent(
    name="assistant",
    instructions="Help users with their questions.",
    input_guardrails=[check_for_pii],
    output_guardrails=[check_for_harmful_content],
)

Google ADK usa segurança baseada em callbacks:

async def safety_callback(context, message):
    if contains_harmful_content(message):
        return "I cannot process this request."
    return None  # Continua normalmente

agent = Agent(
    name="assistant",
    before_model_callback=safety_callback,
    after_model_callback=output_safety_callback,
)

LangGraph trata segurança pela estrutura do grafo:

def safety_check(state):
    if is_unsafe(state["messages"][-1]):
        return {"messages": [AIMessage(content="Request blocked.")], "should_continue": False}
    return state

workflow.add_node("safety", safety_check)
workflow.add_edge(START, "safety")
workflow.add_conditional_edges("safety", lambda s: "agent" if s.get("should_continue", True) else END)

Recuperação de erros

Aqui as diferenças ficam claras:

• OpenAI Agents SDK: Retries automáticos pra falhas transitórias. O modelo se ajusta dinamicamente com erros de ferramentas. Simples mas eficaz.

• Google ADK: Políticas de retry configuráveis no nível do agente e ferramenta. Integração com a infra de tratamento de erros do Google Cloud.

• LangGraph: Tratamento de erros manual pela estrutura do grafo. Você define nós de retry, paths de fallback e fluxos de recuperação explicitamente. Máximo controle, máximo código.

Scorecard de produção

Guia de decisão

Para de perguntar "qual é melhor?" e começa com "qual se encaixa nas minhas restrições?"

Escolhe OpenAI Agents SDK quando:

• Precisa do caminho mais rápido pra um agente funcional. A API mínima significa menos código, menos abstrações pra aprender e iteração mais rápida. Se seu caso é "dar ferramentas pro LLM e deixar ele se virar", é esse framework.

• Precisa de padrões clean de handoff. Suporte ao cliente, triage multi-departamento, fluxos de escalação — o modelo de handoff encaixa perfeitamente nesses casos.

• Integração MCP importa. O suporte first-class ao MCP conecta a um ecossistema crescente de servidores de ferramentas padronizados. Vantagem estratégica à medida que a adoção do MCP cresce.

• Time é novo em frameworks de agentes. A curva de aprendizado é a mais suave das três. Um dev junior consegue montar um agente funcional em menos de uma hora.

Escolhe Google ADK quando:

• Constrói sobre Google Cloud. A integração com Vertex AI e Cloud Run dá deployment gerenciado, auto-scaling e monitoramento sem trabalho extra de infra.

• Precisa de agentes multimodais. Se seus agentes precisam processar imagens, áudio ou vídeo junto com texto, o suporte multimodal nativo do ADK não tem concorrência.

• Quer padrões de orquestração built-in. SequentialAgent, ParallelAgent, LoopAgent cobrem 90% dos workflows multi-agente prontos pra usar. Sem montar grafos.

• Interoperabilidade cross-framework importa. O suporte do ADK ao protocolo A2A (Agent-to-Agent) permite seus agentes se comunicarem com agentes de outros frameworks.

Escolhe LangGraph quando:

• Workflow tem lógica condicional complexa. Se seu agente precisa tomar decisões diferentes com base em estado acumulado, voltar a passos anteriores, ou lidar com dezenas de paths de branching, o modelo de grafo explícito do LangGraph é a única opção que escala.

• Auditoria é inegociável. Pra indústrias reguladas (finanças, saúde, jurídico), o time-travel debugging e o histórico completo de execução do LangGraph fornecem a trilha de auditoria necessária.

• Precisa de human-in-the-loop em pontos arbitrários. O interrupt() do LangGraph pausa execução em qualquer nó, espera aprovação humana, e retoma incorporando o input humano ao estado.

• Tá construindo uma plataforma, não só um agente. Se tá montando um sistema onde outros devs vão criar agentes, a estrutura explícita do LangGraph torna workflows debugáveis e mantíveis por gente que não escreveu o código original.

Abordagem híbrida

Pouco discutido: dá pra misturar frameworks. Parece loucura mas é estrategicamente viável:

• OpenAI Agents SDK pra agentes standalone rápidos (ferramentas internas, chatbots)
• Google ADK pra pipelines multimodais no Google Cloud
• LangGraph pra workflows complexos com estado que precisam de auditoria

O protocolo A2A tá tornando comunicação cross-framework cada vez mais prática. Um agente ADK pode chamar um agente LangGraph, e nenhum precisa conhecer os internos do outro.

O que vem pela frente

Os três tão evoluindo numa velocidade impressionante:

OpenAI Agents SDK (v0.11.1 em março 2026) itera em velocidade recorde. Os releases recentes adicionaram Computer Use tool (GA — agentes podem operar software via interação UI baseada em screenshots), Tool Search (carregamento dinâmico de ferramentas com GPT-5.4 pra evitar sobrecarga de schemas) e transporte WebSocket pra conexões multi-turn de baixa latência. O OpenAI também anunciou o sunset da Assistants API (agosto 2026), empurrando todo mundo pro stack Responses API + Agents SDK.

Google ADK (v1.26.0) mira o mercado enterprise. O ecossistema de integrações em expansão (MongoDB, Pinecone, plataformas de observabilidade) e suporte nativo A2A sinalizam uma visão onde agentes ADK são cidadãos de primeira classe no Google Cloud. O suporte multi-linguagem (Python, Java, Go, TypeScript) amplia o alcance significativamente.

LangGraph (v1.1.0 em março 2026) se consolidou como padrão de produção pra sistemas de agentes complexos. LangGraph Platform (agora parte do LangSmith Deployment) oferece deployment gerenciado, e a integração com LangSmith fornece observabilidade que a concorrência não consegue igualar. LangGraph 2.0 é esperado pro Q2 2026 com maior estabilidade de API e type safety aprimorado. O ecossistema (centenas de integrações LangChain) continua sendo um moat significativo.

A macro-tendência: convergência. OpenAI adiciona mais estrutura. Google torna ADK mais flexível. LangGraph simplifica a API. Em dois anos talvez pareçam mais similares. Mas hoje as diferenças importam — e escolher errado significa semanas de migração.

Conclusão

Não tem vencedor único. Tem um vencedor pra sua situação.

Se quer o resumo honesto numa frase:

OpenAI Agents SDK pra velocidade. Google ADK pra Google Cloud + multimodal. LangGraph pra workflows complexos em produção.

OpenAI Agents SDK é o caminho mais rápido do zero até um agente funcional. Google ADK é a rota mais integrada pra times de Google Cloud. LangGraph oferece o maior controle pra sistemas onde confiabilidade e auditoria importam mais que velocidade de desenvolvimento.

A boa notícia: o ecossistema de frameworks pra agentes AI em 2026 é genuinamente excelente. Os três são production-capable, mantidos por times bem financiados e melhorando rápido. A "má" escolha é não construir agentes — porque a concorrência já tá construindo.

Escolhe o que combina com como seu time pensa, deploya algo real, e itera. O melhor framework pra agentes é o que chega em produção.