---
title: "deepagents vs LangGraph in 2026: When the Anthropic-Style Harness Wins"
description: "deepagents v0.5 ships harness profiles, async subagents, and Anthropic prompt caching baked in. We unpack when this opinionated harness beats raw LangGraph for production agents."
canonical: https://callsphere.ai/blog/vw3g-deepagents-vs-langgraph-when-to-pick-anthropic-style-harness
category: "Agentic AI"
tags: ["deepagents", "LangGraph", "Anthropic", "LangChain", "Agent Harness"]
author: "CallSphere Team"
published: 2026-03-16T00:00:00.000Z
updated: 2026-05-07T09:59:38.259Z
---

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

> deepagents v0.5 ships harness profiles, async subagents, and Anthropic prompt caching baked in. We unpack when this opinionated harness beats raw LangGraph for production agents.

> **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

```mermaid
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"]
```

CallSphere reference architecture

`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](/industries/real-estate) deployment uses an OpenAI Agents SDK orchestrator + 10 specialist agents pattern; our [IT Services UrackIT](/industries/it-services) 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

```python
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](/trial) on the Sales product, mount our research subagent skill, and let it triage your inbound calls.

## Sources

- [deepagents v0.5 Release Notes](https://blog.langchain.com/deep-agents-v0-5/)
- [Releases · langchain-ai/deepagents](https://github.com/langchain-ai/deepagents/releases)
- [Tuning Deep Agents to Work Well with Different Models](https://www.langchain.com/blog/tuning-deep-agents-different-models)
- [Harness Capabilities Docs](https://docs.langchain.com/oss/python/deepagents/harness)

---

Source: https://callsphere.ai/blog/vw3g-deepagents-vs-langgraph-when-to-pick-anthropic-style-harness