deepagents vs LangGraph in 2026: When the Anthropic-Style Harness Wins

TL;DR — LangGraph is the runtime; deepagents is the opinionated harness on top. Pick deepagents when you want Anthropic-style planning, virtual filesystem, subagents, and prompt-caching defaults shipped on day one. Pick raw LangGraph when your topology is custom enough that an opinion is in the way.

What deepagents actually is

flowchart LR
  User --> Triage["Triage / Supervisor"]
  Triage -->|tool A| A["Specialist A"]
  Triage -->|tool B| B["Specialist B"]
  Triage -->|tool C| C["Specialist C"]
  A --> Mem[(Shared memory · mem0/Letta)]
  B --> Mem
  C --> Mem
  Mem --> Final["Final response"]

deepagents (langchain-ai/deepagents) is a Python and TypeScript agent harness built on LangChain primitives and powered by the LangGraph runtime. It ships a planning tool, a virtual filesystem, the ability to spawn subagents, and — as of v0.5.0 alpha (March 2026) — async subagents, multi-modal support, and tuned Anthropic prompt-caching. The repo hit 9.9k stars within five hours of the v0.5 announcement, which tells you the demand for "LangGraph with batteries" was real.

The decision: deepagents or LangGraph?

LangGraph is the lower-level graph runtime. You build your own topology, manage your own checkpointer, and write your own planning logic. deepagents is what LangChain wishes everyone wrote on top of LangGraph: a default loop, default tools, default prompts, harness profiles that swap behavior per model vendor, and middleware hooks for human-in-the-loop, summarization, and storage.

Pick deepagents when:

1. Your agent needs long-horizon planning — research workflows, code rewrites, multi-document synthesis.
2. You want subagents for context isolation without writing the spawn-and-merge yourself.
3. You're multi-vendor — switching between Claude, GPT-5, and Gemini means the harness profiles handle prompt-prefix and tool-naming differences.
4. You want Anthropic prompt caching without learning the breakpoint API.

Pick raw LangGraph when:

1. Your topology is a fixed DAG, not an open-ended ReAct loop.
2. You need custom state schemas that the deepagents harness doesn't model.
3. You already have production checkpointing, observability, and middleware — adding the harness is double bookkeeping.

What's new in deepagents v0.5

The v0.5 alpha changes that matter for production:

• Async subagents return a task ID immediately and run on a remote server, so the parent agent can keep talking to the user while the subagent grinds.
• Harness profiles are a declarative override layer for the prompt prefix/suffix, tool inclusion, middleware selection, and skills — built-ins ship for OpenAI and Anthropic, drawn directly from each vendor's published prompting guides.
• Multi-modal support (images and PDFs) lands in the same loop without writing a custom tool.
• Anthropic prompt caching is on by default for models that support it; cache breakpoints are placed automatically around the system prompt and stable tool definitions.

How CallSphere thinks about this

CallSphere runs 37 specialist agents across 6 verticals, with 90+ tools and 115+ DB tables. Our Real Estate OneRoof deployment uses an OpenAI Agents SDK orchestrator + 10 specialist agents pattern; our IT Services UrackIT wraps deepagents-style planning with a ChromaDB RAG layer for past-ticket lookup. After-hours runs 7 agents with explicit escalation. We don't pick frameworks dogmatically — we pick whichever harness lets us hit p95 latency targets and keep the prompts auditable.

For new internal agents in 2026 we've started defaulting to deepagents when the workflow is long-running and offline (research, summarization, batch outreach), and to raw OpenAI Agents SDK or LangGraph when the workflow is conversational and latency-bound.

Build steps — migrate one LangGraph workflow to deepagents

1. Install: pip install deepagents or npm i deepagents.
2. Pick a harness profile: from deepagents import create_deep_agent, AnthropicProfile.
3. Move your existing tools as-is — deepagents accepts plain LangChain @tool decorators.
4. Replace your manual StateGraph with create_deep_agent(tools=..., instructions=..., subagents=[...]).
5. Add a write_todos tool for built-in planning if you want the harness to expose its plan to the user.
6. Wire your existing LangSmith project ID; tracing comes for free.
7. Benchmark: same input, same model. We've seen 22-40% fewer tokens on Claude due to the prompt-cache defaults.

Code: minimal deepagents agent with subagents

from deepagents import create_deep_agent
from langchain_core.tools import tool

@tool
def lookup_account(phone: str) -> dict:
    """Look up a CallSphere customer account by E.164 phone."""
    # ...real DB call
    return {"plan": "Growth", "mrr": 499}

researcher = {
    "name": "researcher",
    "description": "Pulls public web context on the caller's company.",
    "prompt": "You are a research subagent. Return 3 facts and 2 risks.",
    "tools": ["web_search"],
}

agent = create_deep_agent(
    tools=[lookup_account],
    instructions="You are CallSphere's inbound triage agent.",
    subagents=[researcher],
)

result = agent.invoke({"messages": [{"role": "user", "content": "+18453884261 just called"}]})

Migration story — what we kept, what we threw out

When we ported one of our internal LangGraph workflows (an outbound research agent) to deepagents in March 2026, three things changed:

• Tool definitions stayed verbatim. @tool decorators are LangChain-native; the harness re-uses them directly.
• The supervisor node disappeared. deepagents' default loop replaced about 80 lines of manual ReAct-style supervisor code with one create_deep_agent call.
• The checkpointer config shrank. The harness wires LangGraph's checkpointer with sensible defaults; we only override when we need Postgres durability or a non-default thread-id strategy.

What we still wrote ourselves: the subagent prompts. The harness ships boilerplate that works, but production-quality subagent prompts are vertical-specific and worth investing in — a 200-token "you are a research subagent that returns 3 facts and 2 risks in JSON" pays for itself ten times over.

Cost note — Anthropic prompt caching in practice

The big v0.5 selling point for Anthropic shops is the prompt-cache defaults. The harness places cache breakpoints around the system prompt and stable tool definitions automatically. In our outbound research agent, this dropped per-call cost on Claude Sonnet 4 from $0.012 to $0.0072 — a 40% drop driven entirely by cache hits on the system prompt. For high-volume agents (we run thousands of these per day on the GTM side) that compounds fast.

You don't need to do anything to enable it; just pick the Anthropic harness profile. The library ensures cache breakpoints land on stable boundaries, not in the middle of a tool call where they'd invalidate constantly.

FAQ

Does deepagents replace LangGraph? No — it sits on top of LangGraph. Every deepagents agent is still a LangGraph graph under the hood, so checkpointers, streaming, and human-in-the-loop all still work.

Can I run deepagents with a model other than Claude? Yes. The OpenAI harness profile ships out of the box; community profiles exist for Gemini and DeepSeek.

Is the v0.5 alpha production-safe? Pin to a specific commit and run regression evals before you ship. The async subagents path is the youngest surface and should be feature-flagged.

How do we demo a deepagents-style workflow on CallSphere? Start a 14-day trial on the Sales product, mount our research subagent skill, and let it triage your inbound calls.

Sources

• deepagents v0.5 Release Notes
• Releases · langchain-ai/deepagents
• Tuning Deep Agents to Work Well with Different Models
• Harness Capabilities Docs