LangGraph, CrewAI or Google ADK? One Two-Agent Task, Three Frameworks

Framework comparisons usually run on one template: a feature grid, a paragraph per column and a verdict that avoids recommending anything. That doesn't help someone standing at the fork who needs to choose and move on. The comparison here is built around writing the same small system in LangGraph, CrewAI and Google ADK, so the differences come from code and trade-offs, not a spec sheet.

Three mental models

A quick framing before any code:

• LangGraph is a box of Lego bricks. Every node, edge and conditional branch gets defined explicitly. It offers the most control and the steepest learning curve.
• CrewAI is a pre-assembled team that asks what it should do. Roles and goals are declared, and the framework handles coordination. It's the fastest route to a working prototype, with less say over how agents hand work to each other.
• Google ADK thinks like a senior backend engineer. It's event-driven and stateful, with observability, testability and graceful failure designed in, plus deep ties to Google Cloud and Gemini.

None of these is a criticism. They're different bets on what most developers need most of the time.

The test task

Each framework gets the same job: a researcher gathers material, then a writer turns it into the final answer, so the writer can't start until the researcher is done. A supervisor-style router would handle exactly this, which makes it a fair yardstick for how differently each tool expresses the same flow.

LangGraph

Imports first:

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

Then a typed state, nodes and explicit edges:

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

All edges are drawn by hand here. At any step it's clear what runs next, and that's the price and the payoff of LangGraph: extra code up front in exchange for a control flow the framework never improvises.

CrewAI

from crewai import Agent, Task, Crew

The agents and tasks come next:

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

Notice what's absent next to LangGraph: nobody draws a graph or connects edges. The code states who is responsible for what, and CrewAI's process logic carries the research task's result into the writing task on its own. Reaching a working version takes far less time, nearer to twenty minutes once the pattern is familiar.

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

Look at the sub_agents field. ADK builds on a parent-child hierarchy running on events, and its runtime drives the loop that shuttles between incoming requests, model calls and tool runs. It lands between LangGraph's hand-drawn wiring and CrewAI's implied coordination: you get a hierarchy, but more of the plumbing is handled for you than in LangGraph.

Where they really differ

Toy examples look deceptively alike. The differences show up past the prototype stage.

Control and observability. LangGraph is widely seen as the most production-hardened choice for complex, branching workflows. Checkpointing and durable execution are built in, and Klarna is reported to run it for 85 million users. That kind of production use is a signal apart from any feature list. The cost is the learning curve, which is steepest of the three exactly because control is most explicit.

Speed to first prototype. CrewAI wins consistently. For a first multi-agent system, or a quick idea check, its role-based abstraction gets something running sooner. The flip side is that the same high-level abstraction becomes a ceiling when coordination logic gets complex, since there's less fine-grained control over when and how agents hand off.

Enterprise and language needs. ADK became generally available in 2026 and changed course while doing so, replacing its hierarchical executor with a graph-based engine, which is the design LangGraph had from the start. Its real edge lies elsewhere. It covers more languages than either rival (Python, TypeScript, Go, Java, Kotlin), it plugs straight into Gemini and Google Cloud for teams already there, and it bundles evaluation tooling that LangGraph and CrewAI don't include.

Talking across frameworks. Few comparisons mention this one. ADK supports the Agent2Agent (A2A) protocol natively, so an agent written in another framework entirely can exchange messages with it, and signed agent cards give cryptographic verification. When a system has to call an agent owned by a vendor or partner, A2A does for agents what MCP does for tools: it standardizes the conversation between two agents instead of between an agent and a tool.

Token efficiency. There's a measurable gap too. Benchmarks running the same tasks through LangGraph and CrewAI have found LangGraph spending clearly fewer tokens. The likely reason is that LangGraph moves along explicit edges, whereas CrewAI leans on the LLM to route tasks, and each of those implicit routing choices is a small model call on the bill. Someone pays for the decision either way.

Choosing, in order

Skip the feature tables and ask these questions in sequence:

1. Prototyping fast, or is this a first multi-agent system? Pick CrewAI. It's the quickest path to something working, and the choice can be revisited once the coordination logic proves complex.
2. Need maximum control over branching, explicit error routing or human-in-the-loop checkpoints? Pick LangGraph. When routing is nuanced, you want to own every edge instead of letting framework logic decide.
3. Already on Google Cloud, or need languages beyond Python? Pick Google ADK. Native Gemini and Cloud integration removes friction for teams in that ecosystem, and its language range is unmatched.
4. Must agents from different frameworks or vendors talk to each other? Pick Google ADK for A2A support, the one production requirement neither alternative treats as a first-class feature.
5. None of the above clearly applies? Use whichever your team knows best. All three are production-capable in 2026, and what matters more is how deliberately state, routing and tool layers are designed on top.

No universal winner

No framework is best for everybody, and a comparison claiming otherwise has something to sell. Choose LangGraph for control and production hardening on complex workflows, CrewAI for the shortest time to a working prototype and Google ADK for Google Cloud-centered teams and genuine cross-framework messaging.

Decide from the real constraint, whether that's what the team already knows, which cloud it runs on or how intricate the coordination logic really is, and not from whichever framework had the flashiest recent announcement. The framework is scaffolding. Sound agent design carries over to any of the three: the loop, retrieval, routing, tool standards, observability and a habit of evaluating results.