Google ADK vs LangGraph: Which Agent Framework to Use in 2026

The table lists what each project ships today. Version numbers, licenses and Python requirements come from PyPI and the GitHub repositories; features come from each project's README and docs.

Model choice. ADK's README says it is "optimized for Gemini" but model-agnostic and deployment-agnostic; its examples default to Gemini models. LangGraph has no default model at all: a node is a Python function, so the model is whatever you call inside it, usually through LangChain's chat model integrations.

Community size. At the time of checking, langchain-ai/langgraph had about 44.8K GitHub stars and google/adk-python about 22.2K; the other ADK ports add adk-go (about 9.0K), adk-java (about 1.8K) and adk-js (about 1.5K). Both repositories had commits the day we looked, and ADK's README states a roughly bi-weekly release cadence.

ADK started (first PyPI release April 2025, 1.0 in May 2025) as a code-first way to compose LLM agents into a tree: a root agent delegates to sub-agents, and workflow agents (SequentialAgent, ParallelAgent, LoopAgent) run them in fixed patterns. That was the basis for the common claim that ADK is "hierarchical" and LangGraph is "a graph".

The ADK 2.0 release notes describe a "model-agnostic engine for orchestrating non-linear, conditional, and cyclical agent execution patterns", and the current README lists a Workflow runtime with routing, fan-out and fan-in, loops, retry, state management, dynamic nodes, human-in-the-loop and nested workflows. A Workflow takes edges, and each node can be an agent, a plain Python function, a tool or another workflow; a node's return value becomes the next node's input. ADK 2.0 also added a Task API for structured agent-to-agent delegation.

In practice this means a deterministic pipeline (fetch, then filter, then summarize) no longer forces you toward LangGraph. The snippet below is a three-node ADK workflow where the middle step is ordinary Python. The 2.14 release notes go further and move execution environments, A2A, evaluation and core runtime modules out of experimental status.

The gap that remains. LangGraph's graph is the whole framework: state is a typed dict that every node reads and writes, reducers merge updates, and a checkpointer saves the state after every step so a run can pause for days and resume where it stopped. ADK's workflow passes outputs node to node and keeps conversation state in its session service. If your design centers on resumable, inspectable state (approvals, retries after a crash, time travel through past steps), LangGraph's model is the more direct fit. If it centers on agents that delegate to agents, ADK's is.

Interop exists. ADK Python ships a LangGraphAgent class (google.adk.agents.langgraph_agent) that wraps a compiled LangGraph StateGraph as an ADK agent, so a team can keep an existing LangGraph graph and orchestrate it from ADK, or expose it over A2A through ADK.

This is the dimension that decides most real projects, and it is where the two frameworks are still built differently.

LangGraph. You declare the state schema up front (TypedDict or Pydantic), every node returns a partial update, and a checkpointer (in-memory, SQLite, Postgres, or the managed one in LangSmith Deployment) stores a snapshot after each step under a thread_id. The LangGraph README lists durable execution ("persist through failures and can run for extended periods, automatically resuming from exactly where they left off"), human-in-the-loop ("inspecting and modifying agent state at any point") and short- and long-term memory as its first three features. interrupt() pauses a node and waits for a human value; you resume the same thread later.

Google ADK. A Runner executes an agent against a session from a SessionService (in-memory, database, or the managed sessions on Agent Runtime). Session state is a key-value dict that agents and tools read and write, events are appended to the session, and a separate memory service (Memory Bank on Google Cloud) holds long-term recall. For approvals, ADK's tool confirmation flow guards a tool call behind an explicit yes or custom input, and ADK 2.0 workflows support human-in-the-loop nodes.

If you need fine-grained replay of a long, branching run, LangGraph gives you more control with less code. If your agents are conversational and session-shaped (a support agent, an assistant inside Google Workspace or Gemini Enterprise), ADK's session model maps onto the product with less glue.

Both frameworks are MCP clients, which matters more than any built-in tool list: whatever MCP servers your team already uses work in either one. The code connects each to the same hosted server, TwitterAPI.io's X data MCP server at https://mcp.twitterapi.io/mcp, which takes the key as Authorization: Bearer <key> and exposes tools such as search_tweets, get_user_info, get_user_last_tweets and get_tweet_replies (setup for other clients is on our MCP server page).

ADK. McpToolset with StreamableHTTPConnectionParams(url=..., headers=...) turns every tool on the server into an ADK tool. The ADK docs add two rules worth knowing before you deploy: an agent deployed to production "must define McpToolset synchronously" in agent.py, and the toolset opens its session on first use rather than at construction. The docs also recommend auth_scheme and auth_credential for OAuth-style servers; a static bearer header is fine for an API key.

LangGraph. Since LangChain 1.4, the documented path is MCPAdapter from langchain.mcp (install langchain[mcp]), built on FastMCP; the docs mark it as beta and point users of the older langchain-mcp-adapters package to a migration guide. A bearer token goes on a FastMCP Client(url, auth=token). The adapter returns LangChain tools you can hand to create_agent or to a ToolNode inside your own StateGraph.

A2A (agent-to-agent). ADK treats A2A as a first-class feature: to_a2a() serves an ADK agent with an agent card, and RemoteA2aAgent lets a local agent delegate to a remote one as if it were a sub-agent; the ADK docs still label A2A experimental in Go, Java and Kotlin, while the 2.14 release notes graduate the Python module. In the LangGraph ecosystem, A2A is served by the deployment layer: LangSmith's Agent Server exposes each assistant at /a2a/{assistant_id} with its card at /.well-known/agent-card.json, using the A2A JSON-RPC binding only, with a documented list of unsupported methods and the requirement that graph state include a messages key.

Both libraries are free and open source; you pay for the model calls, the tools, and wherever you run the agent. Each has a managed home from its own vendor, and both also run as an ordinary container.

Google ADK. adk deploy cloud_run and adk deploy docker are built into the CLI; the managed option is Agent Runtime on Gemini Enterprise Agent Platform, which the ADK README notes was formerly Vertex AI Agent Engine. Google's Agent Platform pricing page lists Agent Compute at $0.085 per vCPU-hour and Agent Memory at $0.009 per GiB-hour, rounded to the second, and states that runtime idle time between turns is not billed; sessions and Memory Bank storage bill as Agent Storage at $0.30 per GiB-month plus read and write operations.

LangGraph. You can self-host the open-source library anywhere. LangSmith Deployment is LangChain's managed runtime. The LangSmith pricing page lists Developer at $0 / seat per month (1 seat, up to 5k base traces / mo), Plus at $39 / seat per month (up to 10k base traces / mo, one free small serverless deployment) and Enterprise at custom pricing. Deployments are metered in LangChain Standard Units at $1.00 / LSU: runtime compute 0.0675 LSU / vCPU-hr, runtime memory 0.0090 LSU / GiB-hr, database compute 0.177 LSU / vCPU-hr and database memory 0.025 LSU / GiB-hr.

These rates are list prices as shown on each vendor's page when we checked; neither includes model tokens. Compare total cost on your own workload, not per-unit rates, because the two platforms meter different things (Google bills the agent's compute, LangSmith bills the runtime and its state database separately).

Choose LangGraph if the workflow is the product: long-running runs that must survive restarts, approvals in the middle of a graph, branching you want to replay and debug step by step, or a team that already uses LangChain integrations and LangSmith tracing. It is also the safer choice when you must stay model-neutral and cloud-neutral, and when you want the larger pool of examples and answered questions.

Choose Google ADK if you build on Gemini and Google Cloud (Agent Runtime, Memory Bank, Vertex AI Search, Gemini Enterprise), if your design is a team of agents that delegate to each other, if A2A interoperability with other teams' agents is a requirement, or if parts of your stack are in Java, Go, Kotlin or TypeScript and you want one framework across them. ADK's built-in adk web UI and adk eval also get a first agent tested quickly without a separate service.

Use both if you already have LangGraph graphs and are moving onto Google Cloud: ADK's LangGraphAgent can wrap a compiled graph, and either side can call the other over A2A. The cost of mixing is two mental models for state.

Do not decide on these alone. Both frameworks call tools the same way through MCP, both support any model with some effort, and both are open source with permissive licenses. The differences above (state model, vendor platform, languages, community) are the ones that will still matter after the first prototype.

If your team is new to agents in general, our guide to building an AI agent walks through the loop (model, tools, memory) without committing to a framework, and the OpenAI Agents SDK guide covers a third option with the same X tools.

To compare them on a real task, we built one small agent twice: given an X search query, fetch recent posts and report how many there are, the median likes and the three most-liked posts. The full script is in the code block at the end of this page; it shares one tool function, search_x(), which calls /twitter/tweet/advanced_search on https://api.twitterapi.io with the X-API-Key header and follows next_cursor while has_next_page is true.

In LangGraph the task becomes two explicit nodes, fetch and summarize, joined by edges from START to END. The counting and ranking are deterministic Python, so the run needs no model at all; you add an LLM node only for the prose summary. Add a checkpointer at compile() and the run becomes resumable.

In Google ADK the natural shape is one Agent with search_x passed in tools=[...]: ADK reads the function's signature and docstring to build the tool schema, Gemini decides when to call it, and InMemoryRunner.run_debug() prints the exchange. If you want the deterministic version instead, the ADK 2.x Workflow shown earlier does the same job with a function node.

What the comparison shows. For a fixed pipeline, LangGraph's version is shorter to reason about because nothing is left to the model. For an open-ended research assistant that decides which searches to run, ADK's single agent with tools is less code. Swapping the REST tool for the MCP toolset from the previous section changes one line in either framework.

The X data bill is the same in both. TwitterAPI.io bills tweet endpoints at 15 credits per tweet returned, which is $0.15 per 1,000 tweets; a full 20-post page costs $0.003, and an empty search costs the 15-credit minimum of $0.00015. X's own pay-per-usage rate card (docs.x.com/x-api/getting-started/pricing) charges $0.005 per post read and $0.010 per user read, so the same 1,000 posts cost $5 there versus $0.15 here, about 33x.

Measured on this page. The study below read 961 posts in 50 requests for $0.14; at X's $0.005 per post read the same posts would cost about $4.80. An agent that polls a search every 5 minutes and usually finds nothing pays the minimum on each check: about $1.30 a month, or $6.48 a month at every 60 seconds. New accounts that pass the automatic bot check get up to $1 of free credits (at most 100,000 credits, no card, one per person or network, expiring after 31 days); reads need no X account. Before the first payment the rate limit is 0.2 requests per second, so a tool-calling loop should pace itself; it rises to 20 once paid.

We searched X for the latest posts about each framework with /twitter/tweet/advanced_search (Latest, retweets excluded): 481 posts mentioning Google ADK from 369 accounts and 280 posts mentioning LangGraph from 228 accounts, plus a third search for posts that name both. Then we flagged which topics each post mentions.

MCP is common ground. About one post in five about either framework mentions MCP (23.1% for ADK, 20.0% for LangGraph), which matches the technical picture: tools are portable between them.

A2A and Gemini are ADK's identity. A2A shows up in 13.7% of ADK posts against 3.6% of LangGraph posts, and Gemini in 19.5% against 8.6%. Explicit Google Cloud deploy targets (Vertex, Agent Engine, Agent Runtime, Cloud Run) are rarer than the marketing suggests: 6.4% of ADK posts.

The comparison is one-directional. ADK posts name LangGraph 19.1% of the time; LangGraph posts name ADK 3.2%. LangGraph posts more often mention LangChain (25.7% vs 11.4%) and are more often replies (27.9% vs 13.9%), which reads as an established community talking among itself, while ADK posts position ADK against the incumbent.

Posts that name both are roundups. Of 176 posts that named both frameworks, 70.5% also named CrewAI, 31.2% AutoGen and 25.0% the OpenAI Agents SDK; 81.8% named at least one other agent framework. Head-to-head ADK-versus-LangGraph discussion is rare on X; most of it is "top frameworks" lists.

LangGraph is talked about more. The LangGraph search returned 280 posts spanning 74 hours before the search had no further pages; in that same window ADK drew 101 posts, so LangGraph had 2.8x the volume. ADK's 481 posts spanned about 63 days.

ADK is climbing. ADK's weekly post count ran between 30 and 54 for most of the sample, then jumped to 122 in the last full week before collection. We did not test why; the jump overlaps the ADK 2.14 release on the GitHub releases page, but a single launch post or event could explain it too.

ADK posts reach further per post. The median ADK post earned 4 likes and 315 views; the median LangGraph post earned 1 like and 106 views, and 41.8% of LangGraph posts had no likes at all against 15.4% for ADK. More ADK posts carry media (53.8% vs 33.9%) and GitHub links (17.0% vs 11.1%), consistent with launch and tutorial posts rather than conversation.

How we collected this. Question: what do X posts about Google ADK and LangGraph talk about, and how much attention does each get? Queries: ("google adk" OR "agent development kit" OR "adk-python" OR #googleadk) -filter:retweets, langgraph -filter:retweets, and a co-mention query naming both, run on /twitter/tweet/advanced_search with queryType=Latest, following next_cursor. Window: the most recent matching posts at collection time, collected in 2026. Sample: 961 posts in 50 requests (cost $0.14). Topic flags are case-insensitive keyword matches on the post text.

What the sample cannot show. It counts posts, not users or downloads, and it covers X only; the LangGraph sample spans a few days, so it can over- or under-state a normal week. Keyword flags miss posts that discuss a topic without naming it, and the bare word "adk" in the co-mention query can match unrelated uses (we kept only posts that also named LangGraph). Privacy: authors are mostly private individuals, so we report aggregates only, keep no post text, handles or IDs in the committed sample, and name no individual.