Deep Agents and UHP

Status first

Deep Agents is a distinct in-process agent harness, not a UHP implementation. LangChain’s Python and TypeScript repositories both describe Deep Agents as a batteries-included or opinionated agent harness rather than a low-level graph runtime. The harness supplies planning, filesystem/context tools, subagent delegation and defaults around a model/tool loop while remaining extensible through models, tools, middleware, backends and skills.

The latest observed stable Python release is deepagents==0.7.13, published 2 September 2026 at 17:36:51 UTC. The latest observed stable TypeScript release is deepagents@1.13.3, published 3 September 2026 at 16:06:02 UTC; the first-party TypeScript ACP package is stable deepagents-acp@0.1.29, published three seconds later. Checked upstream main coordinates are Python fc91199a44b99990cca49341169aea858da222fc and TypeScript eb859e8b8e2ae533826c6857a2b0745fdd5e357b at this cutoff.

Caution

No native UHP adoption is established. Reviewed Deep Agents primary sources do not document a UHP endpoint, UHP version declaration or UHP conformance result, and HarnessRouter v0.15.7 does not list Deep Agents among its ten released backends. Reviewed first-party sources also do not establish native A2A support. MCP and ACP are separate interoperability boundaries and must not be reclassified as UHP support.

Why Deep Agents matters to harness architecture

Deep Agents makes the runtime layering explicit. LangChain describes LangGraph as the lower-level graph runtime, create_agent as a minimal harness, and Deep Agents as the opinionated harness built on top. In TypeScript, createDeepAgent() returns a compiled LangGraph graph, so applications retain LangGraph streaming, persistence/checkpointing and runtime capabilities while adopting the higher-level harness defaults.

The documented harness surface includes:

• planning and task breakdown;
• filesystem operations for working/context memory;
• subagents with isolated context windows;
• shell/sandbox execution backends;
• long-context management and persistent memory;
• human-in-the-loop approvals;
• skills and custom tools;
• model-provider portability;
• first-party MCP tool consumption;
• first-party ACP exposure in the TypeScript monorepo.

Those are harness/runtime responsibilities. UHP instead standardizes a network-facing client → UHP server → configured harness execution/lifecycle boundary. A UHP implementation could theoretically wrap a Deep Agents runtime, but no reviewed source establishes such an adapter today.

Boundary map

Layer	Primary job	Verified Deep Agents relationship
Deep Agents	In-process model/tool/subagent loop plus planning, context and execution policy	Native harness surface.
LangGraph	Lower-level graph runtime, persistence/streaming/checkpoint substrate	Deep Agents is built on it.
MCP	Harness → external tools/services	First-party tool integration. Python documentation explicitly allows tools from MCP servers.
ACP	Editor/client → coding agent	First-party TypeScript server package deepagents-acp; current official ACP matrix does not directly probe it.
A2A	Agent → agent interoperability	Not established in reviewed first-party Deep Agents sources.
UHP	Client → UHP server → complete configured harness	No native adoption established.
HarnessRouter	UHP reference implementation → backend adapters	Deep Agents is not in the released ten-backend set at this cutoff.

MCP is a tool boundary, not the outer harness contract

The Python project documents MCP as one way to supply tools to a Deep Agents harness. This places MCP inside the harness’s tool/context plane: the Deep Agents loop decides when to invoke those tools and incorporates results into subsequent reasoning.

That is architecturally different from UHP. MCP tool availability does not supply UHP task/session semantics, and the reviewed sources do not claim that Deep Agents implements the UHP server contract. This page therefore records first-party MCP tool consumption, not a native UHP relationship and not a claim that Deep Agents implements an MCP server.

First-party ACP server

The TypeScript monorepo publishes deepagents-acp, a first-party ACP server for exposing Deep Agents to editors and other ACP clients over JSON-RPC 2.0 on stdio. Stable deepagents-acp@0.1.29 tracks the stable deepagents@1.13.3 runtime.

The documented server maps ACP into several harness capabilities:

• initialize, authentication passthrough, session creation/loading, prompting, cancellation and mode switching;
• session persistence and history replay through LangGraph checkpointers;
• permission requests bridged from configured human-in-the-loop interrupts;
• client terminal execution when ACP terminal capability is available, with local fallback otherwise;
• editor-mediated filesystem reads/writes, including access to unsaved buffers where the client supports those methods;
• tool-call kinds, file locations and diffs for IDE presentation;
• agent, plan and ask operating modes plus advertised slash commands.

The current official ACP protocol matrix generated 9 September 2026 at 09:49:20 UTC probes 33 registry agents and does not list deepagents-acp. Therefore this page treats the first-party implementation as direct upstream evidence, not as ACP registry/matrix interoperability evidence.

Subagent state and budget isolation

Stable TypeScript 1.13.3 materially develops the subagent contract. It applies each declarative subagent’s harness-profile tool exclusions, adds experimental mode: "fork" conversation forking that inherits parent history/system prompt, fixes omitted subagent tool lists to inherit parent tools, and rejects duplicate subagent names at construction.

A later current-main, unreleased fix at eb859e8b addresses a sharper isolation failure. Model-call and tool-call counters had crossed parent/subagent graph boundaries. Upstream reports two consequences: parallel delegation could fail with InvalidUpdateError, while serial delegation could rewind the parent’s call budget and defeat runLimit. The fix excludes those call-count keys from subagent/fork state transfer so each agent counts its own calls while deliberately shared state such as files still propagates.

That fix is deliberately not promoted to stable 1.13.3. Upstream also records a remaining limitation for other custom middleware that carries plain state through forked subagents; the general schema-driven isolation fix is deferred.

This is a useful harness-level distinction for UHP readers: an outer execution protocol can bound tasks and sessions, but the harness still owns correctness of internal delegation, state propagation and model/tool budgets.

Security and approval boundary

Deep Agents’ own security guidance uses a trust-the-LLM model and says boundaries should be enforced at the tool/sandbox layer rather than relying on the model to self-police. That makes backend/tool permissions part of the actual safety boundary.

The ACP server can additionally surface configured interruptOn decisions through ACP permission requests. That is an editor↔agent approval path layered around Deep Agents execution; it does not change UHP security semantics or establish a UHP authorization mapping.

Evidence boundaries

• Python stable: deepagents==0.7.13, published 2 Sep 2026 at 17:36:51 UTC.
• Python checked main: fc91199a44b99990cca49341169aea858da222fc.
• TypeScript stable: deepagents@1.13.3, published 3 Sep 2026 at 16:06:02 UTC.
• TypeScript ACP stable: deepagents-acp@0.1.29, published 3 Sep 2026 at 16:06:05 UTC.
• TypeScript checked main: eb859e8b8e2ae533826c6857a2b0745fdd5e357b; its subagent call-count isolation fix is unreleased current-main behavior.
• First-party MCP tool integration: established.
• First-party ACP server: established for TypeScript; official ACP direct-probe matrix evidence is not established.
• Native A2A: not established in reviewed primary sources.
• Native UHP: not established.
• HarnessRouter backend: not present in v0.15.7’s ten released backends.
• UHP conformance evidence: none attributed to Deep Agents.

Related pages

Read Strands Agents and Pydantic AI Harness for other SDK-oriented harness architectures, Docker Agent for an orchestrator exposing several interoperability protocols, harness composition for delegation topology, UHP vs MCP and UHP vs ACP for protocol boundaries, and ecosystem for adoption classifications.

Primary sources

• Deep Agents Python repository
• Deep Agents Python 0.7.13
• Deep Agents Python README at checked main
• Deep Agents Python checked main fc91199a
• Deep Agents TypeScript repository
• Deep Agents TypeScript 1.13.3
• deepagents-acp@0.1.29
• deepagents-acp README at checked main
• TypeScript current-main subagent isolation fix eb859e8b
• Official ACP protocol matrix
• HarnessRouter v0.15.7