¿LangGraph, CrewAI o Google ADK? Una tarea de dos agentes, tres frameworks.

Las comparaciones de frameworks suelen basarse en un mismo formato: una tabla de características, un párrafo por columna y una conclusión que evita recomendar algo concreto. Eso no ayuda a quienes se encuentran en una encrucijada y necesitan tomar una decisión para seguir adelante. La comparación presentada aquí se basa en desarrollar el mismo sistema sencillo en LangGraph, CrewAI y Google ADK, por lo que las diferencias provienen del código y de los compromisos necesarios, no de una hoja de especificaciones.

Tres modelos mentales

Un breve marco conceptual antes de escribir cualquier código:

• LangGraph es como una caja de ladrillos de Lego. Cada nodo, arista y ramificación condicional se define de forma explícita. Ofrece el mayor grado de control, pero también la curva de aprendizaje más pronunciada.
• CrewAI es un equipo ya formado que pregunta qué debe hacer. Se definen los roles y objetivos, y el marco se encarga de la coordinación. Es la vía más rápida para obtener un prototipo funcional, con menos control sobre cómo los agentes se transfieren el trabajo entre sí.
• Google ADK piensa como un ingeniero senior de backend. Está basado en eventos y tiene estado, con capacidades de observabilidad, pruebas y manejo adecuado de fallos integradas desde el inicio, además de vínculos estrechos con Google Cloud y Gemini.

Ninguna de estas es una crítica. Son enfoques diferentes según lo que la mayoría de los desarrolladores necesitan con mayor frecuencia.

La tarea de prueba

Cada framework cumple la misma función: un investigador reúne el material y luego un redactor lo convierte en la respuesta final, por lo que el redactor no puede comenzar hasta que el investigador haya terminado. Un router de tipo supervisor se encargaría exactamente de esto, lo que lo convierte en un criterio justo para determinar cuán diferente es la forma en que cada herramienta expresa el mismo flujo.

LangGraph

Primero importa:

from langgraph.graph import StateGraph, END
from typing import TypedDict

Luego, un estado tipado, nodos y aristas explícitas:

class State(TypedDict):
    query: str
    research: str
    final_answer: str
def research_node(state: State) -> State:
    # Call your research agent/tool here
    state["research"] = f"Research findings for: {state['query']}"
    return state
def writer_node(state: State) -> State:
    # Call your writer agent, using state["research"]
    state["final_answer"] = f"Final answer using: {state['research']}"
    return state
graph = StateGraph(State)
graph.add_node("research", research_node)
graph.add_node("writer", writer_node)
graph.set_entry_point("research")
graph.add_edge("research", "writer")
graph.add_edge("writer", END)
app = graph.compile()
result = app.invoke({"query": "What is agentic AI?"})

Todas las aristas se dibujan a mano aquí. En cada paso queda claro qué sucederá a continuación, y ese es el precio y la ventaja de LangGraph: código adicional por adelantado a cambio de un flujo de control que el framework nunca improvisa.

CrewAI

from crewai import Agent, Task, Crew

A continuación vienen los agentes y las tareas:

researcher = Agent(
    role="Research Specialist",
    goal="Find accurate information on the given topic",
    backstory="An expert at gathering and synthesizing information."
)
writer = Agent(
    role="Content Writer",
    goal="Write a clear final answer using research findings",
    backstory="An expert at turning research into clear prose."
)
research_task = Task(
    description="Research: {query}",
    agent=researcher,
    expected_output="A summary of relevant findings"
)
writing_task = Task(
    description="Write a final answer using the research",
    agent=writer,
    expected_output="A clear, well-written final answer",
    context=[research_task]
)
crew = Crew(agents=[researcher, writer], tasks=[research_task, writing_task])
result = crew.kickoff(inputs={"query": "What is agentic AI?"})

Observe lo que falta al lado de LangGraph: nadie dibuja un grafo ni conecta aristas. El código indica quién es responsable de qué, y la lógica de procesamiento de CrewAI lleva por sí sola el resultado de la tarea de investigación a la tarea de redacción. Llegar a una versión funcional lleva mucho menos tiempo, cerca de veinte minutos una vez que se conoce el patrón.

Google ADK

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

research_agent = Agent(
    name="researcher",
    model="gemini-2.0-flash",
    instruction="Research the given topic thoroughly and return findings.",
)
writer_agent = Agent(
    name="writer",
    model="gemini-2.0-flash",
    instruction="Write a clear final answer using the research findings provided.",
    sub_agents=[research_agent]  # hierarchical relationship
)
runner = Runner(agent=writer_agent, app_name="research_writer_app")
result = runner.run(user_id="user1", session_id="session1",
                     new_message="What is agentic AI?")

Mira el campo sub_agents. ADK se basa en una jerarquía padre-hijo que funciona a través de eventos, y su tiempo de ejecución impulsa el bucle que se mueve entre las solicitudes recibidas, las llamadas al modelo y las ejecuciones de herramientas. Se sitúa entre el cableado manual de LangGraph y la coordinación implícita de CrewAI: obtienes una jerarquía, pero se maneja más del funcionamiento interno por ti que en LangGraph.

Dónde realmente difieren

Los ejemplos sencillos parecen sorprendentemente similares. Las diferencias aparecen más allá de la fase de prototipo.

Control y observabilidad. LangGraph es considerado ampliamente la opción más preparada para entornos de producción en flujos de trabajo complejos y ramificados. La creación de puntos de control y la ejecución duradera están integradas por defecto, y se dice que Klarna lo utiliza para atender a 85 millones de usuarios. Ese tipo de uso en producción es una señal más importante que cualquier lista de características. El costo es la curva de aprendizaje, la más pronunciada de las tres, precisamente porque el control es el más explícito.

Rapidez para crear el primer prototipo. CrewAI gana de forma consistente. Para un primer sistema multiagente o para probar rápidamente una idea, su abstracción basada en roles permite poner algo en funcionamiento más pronto. Por otro lado, esa misma abstracción de alto nivel se convierte en un límite cuando la lógica de coordinación se vuelve compleja, ya que hay menos control detallado sobre cuándo y cómo los agentes transfieren tareas.

Necesidades empresariales y lingüísticas. ADK se puso a disposición del público en 2026 y cambió de enfoque en ese proceso, reemplazando su ejecutor jerárquico por un motor basado en grafos, que era el diseño original de LangGraph. Su verdadera ventaja radica en otro aspecto: abarca más lenguajes que cualquiera de sus competidores (Python, TypeScript, Go, Java, Kotlin), se integra directamente con Gemini y Google Cloud para los equipos que ya los utilizan, y incluye herramientas de evaluación que LangGraph y CrewAI no ofrecen.

Comunicación entre frameworks diferentes. Pocas comparaciones mencionan este aspecto. ADK admite de forma nativa el protocolo Agent2Agent (A2A), por lo que un agente escrito en otro framework puede intercambiar mensajes con él, y las tarjetas de agente firmadas proporcionan verificación criptográfica. Cuando un sistema necesita llamar a un agente propiedad de un proveedor o socio, A2A hace por los agentes lo que MCP hace por las herramientas: estandariza la comunicación entre dos agentes en lugar de entre un agente y una herramienta.

Eficiencia de tokens. También existe una diferencia medible. Las pruebas de rendimiento que ejecutan las mismas tareas mediante LangGraph y CrewAI han demostrado que LangGraph utiliza claramente menos tokens. La razón probable es que LangGraph sigue rutas explícitas, mientras que CrewAI depende del LLM para enrutar las tareas, y cada una de esas decisiones implícitas de enrutamiento representa una pequeña llamada al modelo en el costo total. De cualquier manera, alguien tiene que pagar por esa decisión.

Elegir en orden

Omite las tablas de características y haz estas preguntas en secuencia:

1. ¿Necesitas prototipado rápido, o se trata del primer sistema multiagente? Elige CrewAI. Es el camino más rápido para lograr algo funcional, y se puede reconsiderar esta opción una vez que la lógica de coordinación resulte compleja.
2. ¿Requieres el máximo control sobre las ramificaciones, enrutamiento explícito de errores o puntos de control con intervención humana? Elige LangGraph. Cuando el enrutamiento es delicado, deseas tener control total sobre cada conexión en lugar de dejar que decida la lógica del framework.
3. ¿Ya estás en Google Cloud, o necesitas lenguajes además de Python? Elige Google ADK. La integración nativa con Gemini y Cloud elimina obstáculos para los equipos de ese ecosistema, y su gama de lenguajes es insuperable.

¿Es necesario que los agentes de diferentes frameworks o proveedores se comuniquen entre sí? Elija Google ADK para soporte A2A, ya que es el único que cumple con los requisitos de producción, algo que las otras alternativas no consideran como una característica fundamental.

Ninguna de las opciones anteriores aplica claramente? Utilice la que su equipo conozca mejor. Las tres son aptas para uso en producción en 2026, y lo que realmente importa es cómo estén diseñados de forma intencional los niveles de enrutamiento y las herramientas que se utilizan sobre ellas.

No hay un ganador universal

Ningún framework es el mejor para todos, y cualquier comparación que afirme lo contrario tiene algún interés oculto. Elija LangGraph para obtener control y mayor robustez en flujos de trabajo complejos, CrewAI para llegar lo más rápido posible a un prototipo funcional, y Google ADK para equipos centrados en Google Cloud y para comunicaciones reales entre diferentes frameworks.

Decida basándose en la verdadera limitación, ya sea lo que el equipo ya conoce, en qué nube se ejecuta o en cuán compleja es realmente la lógica de coordinación, y no según el framework que haya hecho el anuncio más llamativo recientemente. El framework es solo un soporte. Un diseño sólido de agentes es aplicable a cualquiera de los tres enfoques: bucle, recuperación de información, enrutamiento, estándares de herramientas, capacidad de observabilidad y el hábito de evaluar los resultados.