OpenAI Agents SDK vs Google ADK vs LangGraph en 2026: La comparación definitiva

La guerra de frameworks para agentes AI en 2026 tiene un frente claro: OpenAI Agents SDK, Google ADK y LangGraph. Cada uno representa una apuesta radicalmente distinta sobre cómo construir sistemas de IA autónomos.

Hace seis meses, los devs que construían agentes tenían dos opciones: LangGraph para producción seria, o cablear llamadas a APIs manualmente. Ese escenario ya no existe. OpenAI sacó un framework completo para agentes. Google lanzó ADK con integración profunda con Vertex AI. Y LangGraph llegó a 1.0 GA, consolidando su enfoque basado en grafos como production-ready.

El problema es que todos afirman ser "el más fácil" y "el más listo para producción." Los blogs corporativos son básicamente brochures de marketing. Lo que los devs necesitan de verdad es una comparación técnica sin adornos — qué hace bien cada uno, dónde se queda corto, y cuál encaja con tu caso específico.

Eso es exactamente lo que hace este artículo. Sin favoritismos, sin ocultar debilidades. Vamos a comparar arquitectura, integración de herramientas, memoria, patrones multi-agente y madurez para producción con código real. Al final vas a saber qué framework usar — y cuándo evitarlo.

Arquitectura: Tres filosofías

Los tres frameworks no son implementaciones distintas de la misma idea. Representan tres filosofías fundamentalmente diferentes sobre cómo deberían funcionar los sistemas de agentes.

OpenAI Agents SDK: Minimalismo puro

OpenAI apostó deliberadamente por la simplicidad. Todo el framework se reduce a cuatro primitivas: Agents, Handoffs, Guardrails y Tools. Sin grafos, sin motor de orquestación elaborado, sin 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)

La filosofía es clara: construir agentes no debería requerir un doctorado en sistemas distribuidos. Definís un agente con instrucciones y herramientas, lo ejecutás, y obtenés resultados. El loop agéntico (llamar al modelo, ejecutar herramientas, retroalimentar resultados) lo gestiona el SDK internamente.

Lo interesante: a pesar de ser de OpenAI, el SDK es agnóstico de modelo. Soporta más de 100 modelos no-OpenAI a través de la Chat Completions API. Podés enchufar Claude, Gemini, Mistral o cualquier modelo local.

Google ADK: Ingeniería de software aplicada a IA

El Agent Development Kit de Google toma una postura radicalmente distinta. ADK trata a los agentes como componentes de software — modulares, testeables, componibles.

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")])
)

Fijate en la gestión explícita de sesiones, la estructura jerárquica de agentes y el patrón runner. ADK quiere que pienses en agentes como pensás en microservicios: con límites claros, estado explícito y arquitectura componible.

La killer feature: soporte multimodal nativo. Los agentes ADK procesan texto, imágenes, video y audio en el mismo workflow. Y la integración profunda con Google Cloud (Vertex AI, Cloud Run, Agent Engine) te da deployment gestionado de serie.

LangGraph: La máquina de estados

LangGraph modela los workflows de agentes como grafos dirigidos con estado persistente. Cada punto de decisión es un nodo, cada transición es un edge, y todo el flujo de ejecución es explícito e inspeccionable.

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")]})

Es el más verboso de los tres, pero esa verbosidad compra algo crucial: control total sobre el flujo de ejecución. Ves exactamente qué nodo corre cuándo, podés agregar branching condicional, implementar loops, insertar checkpoints human-in-the-loop y debuggear todo el flujo con capacidad de time-travel.

LangGraph es para devs que no confían en cajas negras.

Matriz filosófica

Integración de herramientas: Lo que separa agentes de chatbots

Las herramientas son lo que distingue a un agente AI de un chatbot. Cómo cada framework maneja la definición, ejecución y recuperación de errores de herramientas dice mucho sobre su madurez para producción.

OpenAI Agents SDK: Tres tipos

El SDK ofrece tres categorías:

1. Herramientas hosteadas — Gestionadas por 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 — Tu código personalizado:

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 — Integración con 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)

La integración MCP es particularmente notable. MCP se está consolidando como el protocolo universal para conectar modelos AI con herramientas externas, y el soporte first-class de OpenAI te conecta con cualquier servidor MCP compatible.

Google ADK: Composabilidad ante todo

ADK organiza herramientas por categorías pero enfatiza composabilidad y contexto compartido:

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],
)

La killer feature de ADK: agentes como herramientas:

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 como herramienta!
)

Este patrón agente-como-herramienta es muy poderoso para sistemas jerárquicos donde agentes especializados funcionan como capacidades para orquestadores de nivel superior.

LangGraph: Control máximo

LangGraph te da el control más granular sobre la ejecución de herramientas:

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"  # Ruta a aprobación humana
    return "tools"

La diferencia clave: LangGraph nunca esconde la ejecución de herramientas detrás de abstracciones. Cada tool call es visible en el grafo, podés routear distintas herramientas a distintos nodos, e insertar pasos de aprobación o recuperación de errores donde quieras.

Comparación de herramientas

Memoria y estado: El problema de la persistencia

Un agente sin memoria es solo una llamada API sofisticada. Cómo cada framework maneja contexto de corto plazo, memoria de largo plazo y persistencia de estado determina si tu agente puede manejar conversaciones reales.

OpenAI Agents SDK: Variables 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"})

Para persistencia entre sesiones, el SDK provee SQLiteSession y backends similares. Simple pero no tan sofisticado como sistemas de memoria dedicados.

Google ADK: Arquitectura basada en sesiones

ADK tiene el modelo de memoria más estructurado:

from google.adk.sessions import InMemorySessionService, 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 memoria de corto plazo (estado de sesión, contexto de conversación) de memoria de largo plazo (servicios de memoria pluggables). El concepto de sesión está embebido en el framework — cada interacción ocurre dentro de una sesión, y las sesiones se pueden persistir, resumir y compartir entre agentes.

LangGraph: Checkpointing y time travel

El modelo de memoria de LangGraph es el más potente — y el más complejo:

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 — navegá por el historial completo
    history = [state async for state in app.aget_state_history(config)]
    previous_state = history[2]
    await app.aupdate_state(config, previous_state.values)

El sistema de checkpointing registra cada transición de estado. Esto habilita time-travel debugging, human-in-the-loop en cualquier punto, reanudación de workflows de larga duración, y bifurcación desde cualquier checkpoint.

Comparación de memoria

Orquestación multi-agente: Donde vive la complejidad

Un agente solo es fácil. El desafío real es coordinar múltiples agentes con capacidades distintas. Acá es donde las diferencias entre frameworks se notan más.

OpenAI Agents SDK: Handoffs

El patrón multi-agente del SDK son los handoffs — un agente le transfiere el control a otro:

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)],  # Puede devolver el control
)

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")

Los handoffs son elegantes para flujos de soporte, triage y routing donde el "experto correcto" debe atender la consulta. El modelo decide cuándo transferir basándose en sus instrucciones.

Limitación: los handoffs son esencialmente delegación, no orquestación paralela. No es fácil correr múltiples agentes simultáneamente y mergear sus resultados.

Google ADK: Equipos jerárquicos

ADK soporta múltiples patrones de orquestación 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 secuencial: investigar → escribir → revisar
pipeline = SequentialAgent(
    name="report_pipeline",
    sub_agents=[researcher, writer, reviewer],
)

# O ejecución paralela con merge de resultados
parallel_research = ParallelAgent(
    name="parallel_research",
    sub_agents=[web_researcher, academic_researcher, news_researcher],
)

ADK también tiene LoopAgent para refinamiento 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 y Loop cubren el 90% de los workflows multi-agente sin código de orquestación custom.

LangGraph: Orquestación basada en grafos

LangGraph maneja sistemas multi-agente como subgrafos dentro de un grafo mayor:

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 flexibilidad pero máximo código. Diseñás el flujo exacto, decidís cuándo los agentes corren en secuencia o paralelo, y manejás cada edge case explícitamente.

El patrón supervisor (un LLM decide qué agente corre) y el patrón jerárquico (agentes organizados en equipos con líderes) están bien documentados y probados en producción.

Comparación multi-agente

Producción: Lo que realmente importa

A las comparaciones de frameworks les encanta mostrar ejemplos "hello world." Producción es diferente. Veamos qué ofrece cada framework cuando las cosas salen mal — porque en producción, siempre salen mal.

Observabilidad y tracing

OpenAI Agents SDK viene con tracing integrado:

from agents import trace

with trace("customer_support_flow"):
    result = await Runner.run(triage_agent, user_message)
    # Cada llamada LLM, ejecución de herramienta y handoff queda traceado
    # Visible en el dashboard de OpenAI o exportable a tu stack de observabilidad

Google ADK se integra con la observabilidad de 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 aprovecha LangSmith para observabilidad profunda:

# Cada ejecución del grafo se tracea automáticamente en LangSmith
# Ve ejecución nodo por nodo, transiciones de estado, uso de tokens
# Time-travel a cualquier punto de cualquier ejecución

Guardrails y seguridad

OpenAI Agents SDK tiene guardrails de primera clase:

from agents import Guardrail, GuardrailFunctionOutput, Agent

@input_guardrail
async def check_for_pii(ctx, agent, input_text):
    """Bloquear requests con información personal."""
    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 seguridad basada en callbacks:

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

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

LangGraph maneja la seguridad a través de la estructura del 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)

Recuperación de errores

Acá las diferencias se vuelven evidentes:

• OpenAI Agents SDK: Reintentos automáticos para fallas transitorias. El modelo se ajusta dinámicamente ante errores de herramientas. Simple pero efectivo.

• Google ADK: Políticas de reintento configurables a nivel de agente y herramienta. Integración con la infraestructura de manejo de errores de Google Cloud.

• LangGraph: Manejo de errores manual a través de la estructura del grafo. Definís nodos de reintento, paths de fallback y flujos de recuperación explícitamente. Máximo control, máximo código.

Scorecard de producción

Guía de decisión

Dejá de preguntar "¿cuál es mejor?" y empezá con "¿cuál encaja con mis restricciones?"

Elegí OpenAI Agents SDK cuando:

• Necesitás el camino más rápido a un agente funcional. La API mínima significa menos código, menos abstracciones que aprender y iteración más rápida. Si tu caso es "darle herramientas a un LLM y que se arregle", este es tu framework.

• Necesitás patrones de handoff clean. Soporte al cliente, triage multi-departamento, flujos de escalación — el modelo de handoff mapea perfecto a estos casos.

• La integración MCP importa. El soporte first-class de MCP te conecta a un ecosistema creciente de servidores de herramientas estandarizados. Ventaja estratégica a medida que crece la adopción de MCP.

• Tu equipo es nuevo en frameworks de agentes. La curva de aprendizaje es la más suave de las tres. Un dev junior puede armar un agente funcional en menos de una hora.

Elegí Google ADK cuando:

• Construís sobre Google Cloud. La integración con Vertex AI y Cloud Run te da deployment gestionado, auto-scaling y monitoreo sin trabajo extra de infraestructura.

• Necesitás agentes multimodales. Si tus agentes tienen que procesar imágenes, audio o video junto con texto, el soporte multimodal nativo de ADK no tiene competencia.

• Querés patrones de orquestación built-in. SequentialAgent, ParallelAgent, LoopAgent cubren el 90% de los workflows multi-agente listos para usar. Sin armar grafos.

• La interoperabilidad cross-framework importa. El soporte de ADK para el protocolo A2A (Agent-to-Agent) permite que tus agentes se comuniquen con agentes de otros frameworks.

Elegí LangGraph cuando:

• Tu workflow tiene lógica condicional compleja. Si tu agente necesita tomar decisiones distintas según estado acumulado, volver a pasos anteriores, o manejar docenas de paths de branching, el modelo de grafo explícito de LangGraph es la única opción que escala.

• La auditoría es innegociable. Para industrias reguladas (finanzas, salud, legal), el time-travel debugging y el historial completo de ejecución de LangGraph proveen la trazabilidad que necesitás.

• Necesitás human-in-the-loop en puntos arbitrarios. El interrupt() de LangGraph puede pausar la ejecución en cualquier nodo, esperar aprobación humana, y retomar incorporando el input humano al estado.

• Estás construyendo una plataforma, no solo un agente. Si estás armando un sistema donde otros devs van a crear agentes, la estructura explícita de LangGraph hace que los workflows sean debuggeables y mantenibles por gente que no escribió el código original.

El enfoque híbrido

Algo que rara vez se discute: podés mezclar frameworks. Suena loco pero es estratégicamente viable:

• OpenAI Agents SDK para agentes standalone rápidos (herramientas internas, chatbots)
• Google ADK para pipelines multimodales en Google Cloud
• LangGraph para workflows complejos y con estado que necesitan auditoría

El protocolo A2A está haciendo la comunicación cross-framework cada vez más práctica. Un agente ADK puede llamar a un agente LangGraph, y ninguno necesita conocer los internos del otro.

El panorama que viene

Los tres evolucionan a velocidad impresionante:

OpenAI Agents SDK (v0.11.1 a marzo 2026) itera a velocidad récord. Los releases recientes agregaron Computer Use tool (GA — los agentes pueden operar software via interacción UI basada en screenshots), Tool Search (carga dinámica de herramientas con GPT-5.4 para evitar sobrecarga de schemas) y transporte WebSocket para conexiones multi-turn de baja latencia. OpenAI también anunció el sunset de la Assistants API (agosto 2026), empujando a todos hacia el stack Responses API + Agents SDK.

Google ADK (v1.26.0) apunta al mercado enterprise. El ecosistema de integraciones en expansión (MongoDB, Pinecone, plataformas de observabilidad) y soporte nativo A2A señalan una visión donde los agentes ADK son ciudadanos de primera clase en Google Cloud. El soporte multi-lenguaje (Python, Java, Go, TypeScript) amplía su alcance significativamente.

LangGraph (v1.1.0 a marzo 2026) se consolidó como el estándar de producción para sistemas de agentes complejos. LangGraph Platform (ahora parte de LangSmith Deployment) ofrece deployment gestionado, y la integración con LangSmith provee una observabilidad que la competencia no puede igualar. LangGraph 2.0 se espera para Q2 2026 con mayor estabilidad de API y type safety mejorado. El ecosistema (cientos de integraciones LangChain) sigue siendo un moat significativo.

La meta-tendencia: convergencia. OpenAI agrega estructura. Google hace ADK más flexible. LangGraph simplifica su API. En dos años capaz se parezcan más. Pero hoy las diferencias importan — y elegir mal significa semanas de migración.

Conclusión

No hay un ganador único. Hay un ganador para tu situación.

Si querés el resumen honesto en una oración:

OpenAI Agents SDK para velocidad. Google ADK para Google Cloud + multimodal. LangGraph para workflows complejos en producción.

OpenAI Agents SDK es el camino más rápido de cero a un agente funcional. Google ADK es la ruta más integrada para equipos de Google Cloud. LangGraph ofrece el mayor control para sistemas donde la confiabilidad y la auditabilidad importan más que la velocidad de desarrollo.

La buena noticia: el ecosistema de frameworks para agentes AI en 2026 es genuinamente excelente. Los tres son production-capable, mantenidos por equipos bien financiados y mejorando rápido. La "mala" elección es no construir agentes — porque tu competencia ya lo está haciendo.

Elegí lo que encaje con cómo piensa tu equipo, deployeá algo real, e iterá. El mejor framework para agentes es el que llega a producción.