Managed Agents Compared: Anthropic, LangGraph and Google ADK

Picture 3 a.m. An error lands in Sentry. A bot reads the crash, traces it to a race condition in the payments code, writes a fix and opens a pull request. When the on-call engineer opens Slack at 7, a PR is sitting there waiting for review. Nobody wrote the diff or filed the ticket.

That bot is a managed agent. Building one used to mean six engineers and a quarter of work: a bespoke sandbox, a state store, retry logic, a credential vault and a logging pipeline. Sentry shipped theirs with one team in six weeks, and the difference isn't a smarter model. Someone else now runs the plumbing. The agent takes the root-cause analysis from Seer, Sentry's diagnostic AI, and turns it into a fix PR. Anthropic named it a launch customer on April 10, 2026.

Three vendors now sell this at production scale: Anthropic, LangChain and Google. Their bets differ on how the operating work gets divided between you and them. What follows covers what changed, what each one ships, where each tends to fail and how to choose. The real question isn't which framework is best. It's which operational surface your team wants to own.

What "managed agent" means

Begin with the word "agent." It's software that accepts a task, chooses actions, calls tools, checks how it's going and goes around again. A chatbot isn't that.

"Managed" means the vendor runs the infrastructure: the secure container, the session state, the credentials, the retries after a network blip. You supply the task and the tool definitions. Managed agents relate to hand-rolled agent code the way managed databases relate to self-hosted Postgres. You keep the schema and queries, and the provider handles hardware, backups, failover and monitoring.

Here's how it plays out. You submit a task, say "summarize these three papers into a one-page brief." The provider starts a secure Linux container and the agent begins working inside it, calling tools and writing files while results stream back to you. Close your laptop and it keeps going. Lose the network and it keeps going. Reconnect an hour later and you pick up the stream where you left it. Every action is appended to a durable session log, much like a commit history or an accounting ledger, and that log is the source of truth.

That's the core change. The agent no longer lives inside your process. It's a server-side worker that outlasts disconnects, restarts and sleeping laptops, and you don't write code to get that behavior. There's no code in that picture yet. You specify the work, the vendor operates the worker, and the output outlives your connection.

Why this matters now

Most enterprise agents die at the demo. The notebook runs, the video looks great, and then production asks for things nobody wants to build. You need a sandbox so the agent can't touch the host, a vault so tokens don't leak, persistence so a redeploy doesn't kill a run, retries for timed-out tool calls, observability so the on-call person can tell what happened at 2 a.m., and budget alerts so a stuck loop doesn't burn $500 before anyone notices.

None of that is model work. It's all platform work, and most AI teams have no platform engineers to spare.

Anthropic's pitch targets that gap. Its April 2026 launch materials promise "10x faster to production." That's a marketing claim, not a measurement, but it points at the right pain. Press reports (VentureBeat, so not an Anthropic-disclosed number) put the company's annual recurring revenue past $30 billion, with enterprise accounting for roughly 80%. Managed Agents productizes the spot where that revenue was getting stuck.

Four early customers went live. Notion embeds engineering and knowledge-worker agents in its workspace. Rakuten spreads agents over product, sales, marketing and finance. Sentry ships the PR bot. Asana used it to speed up work on AI Teammates.

The three platforms in brief

They differ in how much the vendor runs and how much you do. Anthropic's is the newest, so it gets the longest treatment below. LangGraph and Google ADK have been around a while.

Anthropic Managed Agents

Launched April 10, 2026, it's the first fully managed agent product from a model provider. Anthropic runs the execution container, the session-history storage, the credential vault, the retry logic for failed tool calls and the tracing. You write two things, the task description and the tool list.

A single run goes like this. You send a POST request saying "start an agent with these tools on this task." Anthropic launches a fresh Linux container, ephemeral, meaning it's created at the start and destroyed at the end so sessions never share a filesystem. Claude runs the loop inside: read the task, pick a step, call a tool, read the result, decide again. Every event is written to a session log that Anthropic keeps on your behalf, an append-only ledger. Events stream back to you over HTTP, and if your connection drops the agent carries on.

Pricing is unusual for infrastructure. You pay normal Claude token rates plus a flat eight cents per active session-hour. A bot running around the clock costs about $58 a month in runtime before tokens, whereas a three-minute run to handle one support ticket costs under a cent. You're billed on session clock time, not CPU time.

The cost of that convenience is coupling. The runtime is built for Claude, so you can't slot in a different model without rewriting the reasoning layer. The way out is the open-source Claude Agent SDK, the same agent loop as a library you host yourself. In exchange you get a runtime that four companies took to production within six weeks of launch. LangChain and Google have shipped agent platforms for about eighteen months, so the novelty here is a fully managed runtime from a model vendor.

LangGraph with LangSmith

This pair is the control plane, tooling that sits over your infrastructure and coordinates how the agent runs. You author the graph, a flowchart of the steps the agent follows. LangChain provides hosting, tracing (a record of every step) and a trace store, the database where those records live and can be searched. The graph library is MIT-licensed, so you can copy, modify or self-host it freely, which gives real portability. The lock-in sits in the trace store, because traces are only fully searchable inside LangSmith.

Google ADK with Vertex AI Agent Engine

This one assumes you already live in Google Cloud. You write agents in Python (Java and TypeScript arrive through 2026) and deploy to Agent Engine, Google's managed runtime on Cloud Run or Kubernetes. The agent inherits your cloud security posture: network perimeter rules, encryption key policy and IAM setup. When your compliance paperwork already speaks Google Cloud, ADK is the quickest road from prototype to something your security team approves.

What Anthropic Managed Agents ships

You describe the job and Anthropic runs it. The code shows how little you write:

import os
import httpx
from anthropic import Anthropic, APIStatusError
# API surface is beta (managed-agents-2026-04-01); confirm against
# platform.claude.com/docs before shipping.
client = Anthropic(
    api_key=os.environ["ANTHROPIC_API_KEY"],
    default_headers={"anthropic-beta": "managed-agents-2026-04-01"},
)
# The Managed Agents surface uses two REST endpoints against the beta:
#   POST /v1/managed-agents/sessions            -> create a session
#   POST /v1/managed-agents/sessions/{id}/runs  -> start a run on that session
# Use httpx directly until the typed namespace stabilizes in the SDK.
BASE = "https://api.anthropic.com/v1/managed-agents"
session = client.post(
    f"{BASE}/sessions",
    json={
        "model": "claude-opus-4-7",
        "tools": ["bash", "code_execution", "web_fetch", "memory"],
        "sandbox": {"network": "egress_allowlist", "timeout_hours": 24},
        "system": (
            "You are a research summarizer. Fetch the top three papers "
            "on retrieval-augmented generation from arXiv this week, "
            "run eval code, and write a one-page brief."
        ),
    },
).json()
run = client.post(
    f"{BASE}/sessions/{session['id']}/runs",
    json={"input": "Start the weekly research brief."},
).json()
# Stream run events; wrap to survive transient disconnects.
try:
    with client.stream("GET", f"{BASE}/runs/{run['id']}/events") as events:
        for event in events.iter_lines():
            print(event)
except (httpx.RemoteProtocolError, APIStatusError) as e:
    # Persist run['id'] and reattach with GET /runs/{id}/events; the
    # session log survives disconnects so the agent is not lost.
    raise

That's a production agent in a few dozen lines. There's no Kubernetes manifest, no sandbox image to maintain, no checkpointer setup. The managed-agents-2026-04-01 beta header enrolls you in what Anthropic's engineers describe as a meta-harness, made of three separate pieces.

The session is the append-only log. Tool calls, agent messages and observations all get written there, a durable record you can replay end to end. The harness is Claude plus the tool interfaces, the loop that reads from the session, chooses the next action, calls the tool and writes the result back. The sandbox is an ephemeral Linux container, spun up per task and discarded at the end. Git credentials and MCP OAuth tokens are kept in vaults that sit outside the sandbox, so the agent can point at them without ever holding them.

Session persistence is the feature people undersell. A multi-hour research task doesn't restart when the client disconnects. The session stays put, the harness reattaches and the agent continues. Anyone who has babysat a long agent job over flaky wifi will appreciate that.

On cost, the $58 monthly figure for a 24/7 agent stings less when the alternative is six weeks of custom sandbox work. On proof, Notion ships engineering agents next to knowledge-worker agents, Rakuten hooked agents into Slack and Teams across several departments and gets back spreadsheets, slides and apps, Sentry's agent writes the fix and opens the PR, and Asana credits the platform with freeing the team to work on multiplayer UX instead of runtime plumbing.

The lock-in is real: you can't swap Gemini or GPT into one step without leaving. The escape hatch is the Claude Agent SDK, and that SDK can run on AWS Bedrock, Google Vertex AI or Azure AI Foundry. If your logic is written against SDK interfaces from day one, leaving the managed runtime is a deployment change, not a rewrite.

What LangGraph ships

LangGraph hands you the parts and you assemble them.

import os
from langgraph.graph import StateGraph, START, END
from langgraph.checkpoint.postgres import PostgresSaver
from typing import TypedDict
class State(TypedDict):
    query: str
    sources: list
    draft: str
    approved: bool
def fetch_sources(state: State) -> State:
    # implement with your retrieval and LLM layer
    return {"sources": retrieve(state["query"])}
def draft_answer(state: State) -> State:
    # implement with your retrieval and LLM layer
    return {"draft": synthesize(state["sources"])}
def human_review(state: State) -> State:
    # interrupt; resumes when approval is posted
    return state
graph = StateGraph(State)
graph.add_node("fetch", fetch_sources)
graph.add_node("draft", draft_answer)
graph.add_node("review", human_review)
graph.add_edge(START, "fetch")
graph.add_edge("fetch", "draft")
graph.add_edge("draft", "review")
graph.add_conditional_edges(
    "review",
    lambda s: "done" if s["approved"] else "draft",
    {"done": END, "draft": "draft"},
)
# Never hardcode DSN - pull from env and configure a connection pool in prod.
DSN = os.environ["POSTGRES_DSN"]
app = graph.compile(checkpointer=PostgresSaver.from_conn_string(DSN))

Think of LangGraph as a state-machine editor for agent behavior. The graph defines the next step and the data passed along. Each node is a plain function, each edge is declared, and every branch can be audited.

LangChain renamed LangGraph Platform to LangSmith Deployment in October 2025. LangSmith now serves over 300 enterprise customers and has handled more than 15 billion traces and 100 trillion tokens. That volume is the moat, since the operational lock-in is in observability and not in the MIT graph library.

The customers argue for control. Klarna's assistant, built on LangGraph and LangSmith, serves 85 million active users and cut resolution time by 80%. Uber's developer platform team built Validator for violation detection and AutoCover for test generation, serving 5,000 engineers and reportedly saving 21,000 developer hours. Replit's coding agent runs multi-agent workflows with human approval for package installs and file creation, and LangChain had to extend trace ingestion to handle traces hundreds of steps long. LinkedIn (an AI recruiter) and AppFolio (a property-manager copilot, reportedly with doubled decision accuracy) appear in LangChain's case-study index, but check the current customer page before treating them as settled.

A pattern shows up: once a workflow has more than three branches or a human approval gate, teams choose LangGraph, because higher-level abstractions hide loops, branches, checkpoints and persistence that complex agents need.

Costs have a different shape from the managed runtimes. There's a free Developer tier with metered limits, and the exact thresholds change, so check LangChain's pricing page. No matter where it runs (SaaS, hybrid or self-hosted), the infrastructure bill is yours. Credential handling on the SaaS tier may differ from the self-hosted default, so verify it against the enterprise docs for your path. LangChain's own framing is blunt: high-level abstractions get you started quickly, low-level flexibility handles varied production queries, the learning curve is steeper, and teams don't migrate away. Replit and Uber are the evidence.

What Google ADK ships

ADK is opinionated workflow primitives plus inherited compliance. You write agents in code, deploy to Vertex AI Agent Engine and keep your security posture.

from google.adk.agents import LlmAgent, SequentialAgent, ParallelAgent
from google.adk.tools import built_in_tools, VertexAISearchTool
search_agent = LlmAgent(
    name="research",
    model="gemini-2.5-pro",
    instruction="Retrieve the top 3 papers on RAG from the last 7 days.",
    # replace with your Vertex AI Search datastore resource path
    tools=[VertexAISearchTool(datastore="projects/.../ragDatastore")],
)
analyze_agent = LlmAgent(
    name="analyze",
    model="gemini-2.5-pro",
    instruction="Summarize findings and extract evaluation methodologies.",
)
# Mandatory: prevent thinking-loop cost bombs before you deploy.
#  - In code, cap iterative work by wrapping retry-heavy steps in a
#    LoopAgent with a small max_iterations.
#  - In Cloud Console: Billing > Budgets & Alerts > set a project-level
#    budget alert (e.g., $10/day) with notification channel configured.
pipeline = SequentialAgent(
    name="weekly_brief",
    sub_agents=[search_agent, analyze_agent],
)
# Deploy to Vertex AI Agent Engine with inherited VPC-SC + CMEK.
# Set billing budget alerts in Cloud Console before deploying to prod.
from vertexai import agent_engines
remote = agent_engines.create(
    agent_engine=pipeline,
    requirements=["google-adk", "google-cloud-aiplatform"],
    display_name="weekly-research-brief",
)

The primitives tell the story. SequentialAgent runs steps in order, ParallelAgent runs them concurrently and LoopAgent repeats a step until a condition holds. The underlying graph primitive covers arbitrary shapes, so four architectures are available out of the box. The Python release is at 1.0.0 and production-ready, Java is at 0.1.0, and a TypeScript release is due through 2026.

The wedge isn't the framework. It's what Agent Engine gives you on deployment. VPC Service Controls, Google's network perimeter, decide who can reach what. Customer-Managed Encryption Keys let you, not Google, control data encryption. IAM agent identity makes the agent a security principal with its own policy bindings. Audit trails come from Cloud Trace and Cloud Logging. ADK also bundles 100+ prebuilt connectors (AlloyDB, BigQuery, NetApp, among others) and speaks Google's Agent-to-Agent protocol for interoperability.

At rest it's cheap. Agent Engine charges $0.00994 per vCPU-hour and $0.0105 per GiB-hour, tokens and tool calls are separate line items, and there's a free tier. A third-party benchmark found ADK with Gemini cold-starting a bit faster than LangChain with Gemini. That's a directional signal at best, so measure your own workload before you repeat it in a meeting.

Why inheriting VPC-SC matters

ADK has no marquee case study on the scale of Klarna or Uber yet. It's a newer entrant. Google's GEAR program, with 35 monthly learning credits and a certification path, subsidizes enterprise ADK training, much as AWS subsidized Well-Architected a decade back, and the case studies are still being built.

Where ADK wins today is the compliance boundary. A regulated company that already has VPC-SC perimeters, CMEK policies and IAM principals defined gets an ADK agent that inherits all of them with no extra configuration, which is worth more than any framework feature. You're buying the option that fits inside your existing security story. For teams without VPC-SC requirements, the governance argument weakens, and LangGraph or Managed Agents probably shortens the path further.

The ownership matrix

With the three platforms laid out, here's the comparison that counts: who owns each operational surface in production. Read it as a who's-on-call grid. Two rows matter far more than the rest, and many enterprise teams misjudge both during evaluation.

Sandboxing. Choose LangGraph and the sandbox is yours. You build the container image, configure network egress, decide where the filesystem is ephemeral and rotate CVE patches. Anthropic and Google ship this by default. If your platform backlog is already four quarters deep, sandboxing as a service buys back a quarter.

Credentials. Managed Agents keeps Git tokens and MCP OAuth tokens in vaults outside the sandbox. Google ADK uses IAM agent identity, so the agent is a principal with its own policies. LangGraph leaves credential management to your deployment, although the LangSmith Deployment SaaS tier includes managed handling, and you should confirm the specifics in your contract.

That last row is the subtle blast radius. If the agent touches production databases and your pattern is one shared secret, LangGraph gives you nothing that fails closed.

Runtime cost matters less than either row. Observability cost matters a lot over time, since LangSmith's trace bill is where LangGraph's total cost shifts from predictable to surprising.

Where each one breaks

Each platform has its own characteristic way of failing in production. The examples below come from vendor documentation or from practitioners who've run them.

Anthropic: compaction. That's when the agent trims session history to fit the model's context limit. Anthropic's engineering blog says plainly that compaction makes irreversible decisions about what to keep, and notes that it's hard to know which tokens future turns will need. In practice, the harness can drop context the agent needs later, and the run fails. The first test in any evaluation is a task needing information from the first 20% of a session after the 80% mark. If that fails silently, you've found the platform's edge.

Google ADK: the thinking loop. A Composio field report describes a $5 charge from one stuck session where an agent kept calling a failing tool, retrying and calling again, burning minutes of vCPU while tokens piled up. The Composio engineer's write-up says the demos looked great but the production version failed most tool calls and ran up $5 in repeated-call costs. Composio has a commercial interest in the ADK comparison, so read it as a single practitioner's account. The mitigation is the lesson: budget alerts, maximum session durations and tool-call rate limits from day one. The platform will cheerfully let an agent spin itself into debt.

LangGraph: the multi-agent wall. Analysis from Latenode says more than 75% of multi-agent systems get harder to manage past five agents, with race conditions, deadlocks, state corruption and memory exhaustion. Treat that as analyst research, not an independent study, though it matches what Replit and Uber have described. The tax doesn't show up at the first agent or the third. It arrives at the sixth, when graph edges stop being obvious, checkpointer state gets hard to reason about and human-in-the-loop checkpoints tangle with async branches. Teams that win on LangGraph keep graphs under five nodes or invest heavily in observability. The ones who lose try to wire a ten-agent swarm without either.

These failure modes are architectural rather than operational, so better engineering won't remove them. You choose the platform whose failure you can afford.

Picking in an afternoon

Three questions settle most of it.

Does this need to ship this quarter? If so, Managed Agents is the default, because for teams without VPC-SC requirements nothing else shortens the prototype-to-production path as much. Soften the Claude lock-in by writing agent logic against the Claude Agent SDK's interfaces now, so you can move to self-hosted Bedrock or Vertex later.

Is the design more than five branches, or does it need human approval at several points? Then LangGraph, provided your team has platform capacity. Klarna, Uber and Replit are the evidence, and the steeper learning curve buys primitives that won't surprise you at 3 a.m.

Is your workload already on Google Cloud, with VPC Service Controls required? Then ADK with Agent Engine is the easy path. Compliance comes free, and the cost at rest is the lowest of the three. Budget for the thinking-loop tax during evaluation.

Condensed into a table in your head: for shipping this quarter, Managed Agents is the fastest, LangGraph needs platform investment and ADK needs GCP expertise in-house. For complex architectures with more than five branches or approvals, Managed Agents is limited because its harness is opinionated, LangGraph is the default choice, and ADK covers most shapes with its primitives. If GCP with VPC-SC is mandatory, Managed Agents needs extra integration work, LangGraph means you build the perimeter, and ADK inherits it natively. For multi-model workloads, Managed Agents is Claude-only (use the Agent SDK for portability), while LangGraph is model-agnostic and ADK treats Gemini as first-class with other models reachable through LiteLLM or OpenAI-compatible endpoints.

AWS Bedrock AgentCore deserves a brief nod as a fourth path. It suits shops that run everything on AWS and want a single compute layer under the Claude Agent SDK, LangGraph and CrewAI, at $0.0895 per vCPU-hour and $0.00945 per GB-hour. It's infrastructure rather than a framework decision, so it stays out of the comparison.

Try the same agent on all three

Implement one small agent on each stack: a weekly digest that grabs three recent arXiv papers about retrieval-augmented generation, runs a short evaluation script and drafts a single page. Track how long it takes to get from clone to a working run, what each run costs, and how fast you can work out why a run failed.

For Managed Agents, the earlier snippet is the whole scaffold: one session create, one run create and one event stream with error handling around disconnects. Set ANTHROPIC_API_KEY, run it once, then force a client restart and confirm the session log survives by reattaching through GET /runs/{id}/events. With a Claude API key, a first successful run should take under an hour.

With LangGraph, the graph is only half the job. The other half is a Postgres checkpointer plus somewhere to deploy. The smallest setup looks like this:

# 1. Postgres (any managed or docker-run instance)
export POSTGRES_DSN="postgresql://user:pass@host:5432/langgraph"
# 2. Install and run the compiled graph
pip install "langgraph[postgres]" langsmith
python summarizer_graph.py                # runs the StateGraph from above
# 3. Deploy (LangSmith Deployment OR self-hosted)
pip install langgraph-cli
langgraph deploy --config langgraph.json  # SaaS tier
# or: docker run ghcr.io/langchain-ai/langgraph-api ...

Plan on half a day. The first half hour is configuration, and the next three hours go to deciding where the human checkpoint belongs and how to retry on tool failure.

For ADK, the SequentialAgent is the agent logic, and the runtime half is gcloud auth plus an Agent Engine deploy. Minimum scaffolding:

# 1. Auth + enable APIs
gcloud auth application-default login
gcloud services enable aiplatform.googleapis.com
# 2. Install and deploy
pip install google-adk google-cloud-aiplatform
python deploy_summarizer.py               # runs agent_engines.create(...)
# 3. Governance wiring (inherited, not configured in code)
#    - VPC-SC perimeter: Console > Security > VPC Service Controls
#    - CMEK: Console > Security > Cryptographic Keys
#    - Budget alert: Console > Billing > Budgets & Alerts

Plan on half a day here too, mostly IAM and VPC-SC setup, which is exactly why you chose ADK in the first place.

Run each for a week. Compare your LangSmith trace bill, Claude session-hour charges and Vertex AI Agent Engine invoice, and read all three failure reports. Ship the platform that matches your team's real engineering capacity.

What to remember

Agent platforms in 2026 have moved from "can we build this" to "which tradeoff will we live with for years." All three stacks here have real customers, real numbers, real failure modes and real pricing, and none is strictly better. They're aimed at different operational surfaces. The choice is a self-assessment of your platform team, compliance footprint and appetite for engineering work, so pick for the team you have, not the one you wish you had.

1. Managed Agents takes you from prototype to production in days, not months, but it ties you to Claude. If several model vendors must stay in play, code against the Claude Agent SDK and host it yourself on Bedrock, Vertex AI or Azure AI Foundry.
2. Test compaction first. Build a task that needs the earliest 20% of the session after the 80% mark, since Anthropic's own engineering blog flags that as the edge where sessions fail silently.
3. LangGraph fits when your architecture has more than five branches or needs human approval at several points. If you're scaling off a higher-level framework, you're building the wrong thing on it, so move to the graph model before the multi-agent wall hits.
4. ADK fits teams whose security boundaries already live in VPC-SC, IAM and CMEK, and the governance inheritance is worth more than any benchmark. Alerts, session duration limits and tool-call rate limits are mandatory from the start.
5. Write your tools as MCP or OpenAPI contracts right away. Orchestrators come and go, from Managed Agents to LangGraph, LangGraph to ADK, or any of them to AWS Bedrock AgentCore, but tool contracts can't. MCP has an engineering cost, especially for tools with complex auth, yet that cost is smaller than the portability it buys.