DeepAgents vs HagiCode: Features and Comparison

DeepAgents is LangChain's open-source agent harness, and its terminal coding agent is now called Deep Agents Code (`dcode`). HagiCode is a workbench that runs it as an executor over ACP. Stay with the CLI for sandboxes, SDK work and scripts; add HagiCode for parallel sessions, proposals and managed commits.

Updated: Oct 16, 2026

Short answer

DeepAgents is LangChain's open-source agent harness, built on LangGraph. Its terminal coding agent, which HagiCode calls DeepAgents, is published as Deep Agents Code: install it, run dcode, and it behaves like a coding agent in your terminal. HagiCode is a desktop and web AI programming workbench that drives agent CLIs, DeepAgents among them, as its executor. It does not replace the CLI; it launches it in ACP mode and adds sessions, proposals and commit handling.

If you build your own agents on the Deep Agents SDK, want remote sandboxes or LangSmith tracing, or only need a terminal, stay with DeepAgents alone. If you want to run it next to other agents with proposals and parallel sessions, add HagiCode. One practical note: the CLI was renamed, so check the setup steps below before connecting it.

DeepAgents vs HagiCode at a glance

Dimension	DeepAgents	HagiCode
What it is	LangChain's open-source Deep Agents harness; the terminal coding agent is Deep Agents Code (dcode)	Workbench that runs agent CLIs, DeepAgents included, as executors
Interface and platforms	Terminal UI with conversation resume, plus headless mode for scripts and CI; Python 3.12+	Desktop app (Windows, macOS, Linux), Docker Compose container, Microsoft Store edition
Pricing and licensing	MIT-licensed and free; you pay your model provider; LangSmith tracing is a separate optional service	Desktop and Container free; Store edition free with optional one-time TurboEngine purchase
Model and provider access	OpenAI, Anthropic and Gemini by default; extras for NVIDIA, Ollama and others; any tool-calling model	Hosts no models; passes your chosen model to the CLI; optional OmniRoute routing
Parallel work	Sub-agents with isolated context inside a session; sessions can be resumed	Several sessions at once, each a named Agent with visible status
Spec and planning workflow	The agent plans and manages its own context; no proposal lifecycle	OpenSpec proposals: propose, validate, apply, archive (3 concurrent free, 32 with TurboEngine)
Git and commit handling	Shell access with human-in-the-loop approval; no dedicated commit workflow documented	AI-composed commit messages with the repository locked during the commit; Git and GitHub integration
Setup effort	curl -LsSf https://langch.in/dcode | bash, then dcode	Desktop install, plus the CLI reachable under the command HagiCode launches
Best for	Developers who want an extensible LangChain-based harness, sandboxes and tracing	Coding work across repositories with parallel sessions and traceable specs

What DeepAgents does well

A harness built for long-horizon work

Deep Agents bundles planning, a filesystem over local, sandboxed or remote backends, context management that summarises long threads and offloads tool output to disk, and sub-agents with isolated context windows. The defaults are tuned for multi-step work rather than single completions.

Remote sandboxes and an honest security model

Deep Agents Code can run code in remote sandboxes such as LangSmith, AgentCore, Daytona, Modal and Runloop. Its README is direct that by default it trusts the directory you run it in and reads project files before any approval prompt, so untrusted repositories belong in a sandbox.

Model-agnostic and extensible

Any model that supports tool calling works, from frontier APIs to Ollama, vLLM or llama.cpp. You can add skills as custom slash commands, persistent memory and MCP tools. The same harness is available as the deepagents Python SDK, and dcode --acp serves it to ACP clients.

Fast-moving, with a naming change

Releases land often: deepagents 0.7.26 and deepagents-code 0.1.85 in October 2026. Deep Agents Code was forked from the older deepagents-cli at v0.1.0 in May 2026, and the deepagents-cli package on PyPI is now marked deprecated and repurposed, so use the new name when you search or install.

When to choose DeepAgents, and when to choose HagiCode

Choose DeepAgents when

• you build your own agents on the Deep Agents SDK or LangGraph and want the CLI as a working reference;
• you need remote sandboxes, or want LangSmith tracing of every agent decision;
• you want to pick any tool-calling model, including local ones through Ollama or vLLM;
• you script headless runs, or only need a terminal;
• you want the newest dcode features the day they ship.

Choose HagiCode when

• you run several DeepAgents sessions at once and want each tracked as a named Agent;
• you want each change to start as a written OpenSpec proposal with validation and archive;
• you want DeepAgents' edits committed with generated messages, plus an embedded editor in one window;
• you also use other agent CLIs and want one workspace for all of them;
• you want notes from earlier DeepAgents runs kept in a shared Vault, and specs spanning repositories through Monospecs.

Where HagiCode is not the right tool for DeepAgents users

Headless CI or scripted runs: use dcode or the SDK directly; HagiCode is a desktop and web app.

The CLI was renamed: HagiCode's launcher looks for a deepagents command with --acp, or uvx --from deepagents-cli, and the old package is deprecated. You may need to point HagiCode at dcode.

HagiCode's DeepAgents settings cover the binary, model, agent name, skills directories and memory files; remote sandbox backends and other dcode options are not among them.

It needs the CLI installed and a model provider configured first, so setup is longer than running dcode alone.

Free editions cap concurrent proposals at 3, and teams that do not want spec discipline will find proposals overhead.

HagiCode is not an IDE replacement for deep manual editing beyond the embedded Code Server.

Using DeepAgents together with HagiCode

HagiCode is a workbench on top of the CLI. It launches the DeepAgents with --acp in the repository you open, so your own install and provider keys do the work. HagiCode adds no model billing.

Nothing is locked in: the CLI remains a normal install you can run with dcode at any time.

1. Install Deep Agents Code with curl -LsSf https://langch.in/dcode | bash, run dcode once and configure a model provider.
2. Check which command HagiCode will find: it looks for deepagents, then falls back to uvx --from deepagents-cli. If neither works, set the DeepAgents binary path in HagiCode to your dcode executable (dcode --acp is the documented ACP entry; this pairing has not been tested end to end).
3. Install HagiCode Desktop (Windows, macOS or Linux; free) and choose DeepAgents as the Agent CLI.
4. Optionally set the model, agent name, skills directories and memory files, then open a repository.
5. Start a session or an OpenSpec proposal; HagiCode talks to the CLI over ACP.
6. To go back to plain dcode, run it directly in the same directory.

What works for DeepAgents inside HagiCode

Parallel sessions, Agents management, OpenSpec proposals, AI commit, Code Server, Monospecs, Vault and the unified tool-call view apply to DeepAgents sessions. OmniRoute is a HagiCode feature, and how far it reaches the CLI depends on the CLI's own model settings.

Interactive questions are limited to Claude, Pi, OMP and Reasonix, and the agent work panel is Claude only, so neither is available with DeepAgents.

What HagiCode adds on top of any agent

Parallel sessions and Agents management

DeepAgents delegates to sub-agents inside one session. HagiCode adds the level above: several DeepAgents sessions across tasks or repositories, each a named Agent with visible status.

OpenSpec proposals

Tracing in LangSmith records what the agent did; an OpenSpec proposal records why. The problem statement, agreed approach and resulting changes stay together and can be archived.

AI commit and Code Server

HagiCode drafts the commit message from the diff and locks the repository during the commit. Code Server opens the files the agent edited in a browser editor.

Monospecs and Vault

Monospecs lists sub-repositories in .hagicode/monospecs.yaml, so cross-repo work reaches the agent as one proposal. Vault holds reference projects and notes you register once, beside the CLI's own memory files.

OmniRoute, tool-call view and usage

OmniRoute can centralise model routing across agents. DeepAgents tool calls appear in the same typed view as every other agent's, and optional TokenMonitor shows today's tokens and cost in the status bar.

The bottom line

• DeepAgents is LangChain's extensible, sandbox-capable harness; its CLI is now Deep Agents Code.
• HagiCode adds parallel Agents, proposals, AI commits and a knowledge base around it, at the cost of an extra install and a launcher name to check.
• Use dcode alone for sandboxes, SDK work and scripts; use HagiCode plus DeepAgents for organised multi-repo coding.

Frequently asked questions

Is DeepAgents free?

Yes. Deep Agents and Deep Agents Code are MIT-licensed. You pay your model provider, and LangSmith tracing is a separate optional LangChain service; see the LangChain pricing page for plans.

How do I install the DeepAgents?

Run curl -LsSf https://langch.in/dcode | bash, then start it with dcode. OpenAI, Anthropic and Gemini support is included; other providers come as extras, for example DEEPAGENTS_CODE_EXTRAS="nvidia,ollama".

Is DeepAgents the same as Deep Agents Code?

Deep Agents Code, package deepagents-code, was forked from deepagents-cli in May 2026 and is the maintained terminal agent. The old deepagents-cli package on PyPI is now deprecated.

Can I use DeepAgents with HagiCode?

Yes, over ACP. HagiCode launches deepagents --acp, or falls back to uvx --from deepagents-cli; with the renamed CLI you may need to set the binary path to dcode.

Does HagiCode replace DeepAgents?

No. The CLI does the work; HagiCode organises sessions, proposals and commits around it, and you can still run dcode directly.

DeepAgents vs HagiCode: which should I pick?

Pick the CLI alone for sandboxes, SDK work and scripts. Add HagiCode when you run several sessions or repositories and want proposals, commits and Agents managed in one place.

Try HagiCode on top of the agent you already use

Install HagiCode Desktop, connect your existing CLI, and keep working the way you do today.

Install HagiCode Desktop

More comparisons

• Claude Code vs HagiCode
• CodeBuddy vs HagiCode
• Codex vs HagiCode
• GitHub Copilot vs HagiCode
• DeepSeek Harness (dsh) vs HagiCode
• Gemini vs HagiCode
• Hermes Agent vs HagiCode
• Junie vs HagiCode
• Kimi vs HagiCode
• Kiro vs HagiCode
• OMP vs HagiCode
• OpenCode vs HagiCode
• Pi vs HagiCode
• Qoder vs HagiCode
• Reasonix vs HagiCode