DeepSeek Harness vs Claude Code & Codex: Which Fits?

DeepSeek Harness is an MIT-licensed developer-preview agent runtime, not a new model. Its distinguishing idea is that the model adapter, agent loop, tools, session log, execution providers, and user surfaces all participate in the same plugin graph.

Bottom line: choose DeepSeek Harness when replacing those runtime pieces is the goal. Choose Claude Code or Codex when you need a more complete coding workflow today: Claude Code for an integrated Claude experience, or Codex for explicit approval and sandbox controls, noninteractive automation, and App Server or SDK embedding.

This comparison maps what six systems own, where their security and “local” boundaries sit, and which job each fits. It does not benchmark answer quality. If you want to run Harness first, follow our tested local setup guide, then return for the architectural trade-offs.

DeepSeek Harness vs Claude Code and Codex: the short answer

For the three names most readers are deciding between, the choice is direct:

This is an architecture and operational-fit comparison, not a benchmark. The table does not rank answer quality, speed, or token use.

The other three systems answer different questions. pi is a deliberately minimal coding loop. OpenClaw is an always-on Gateway that can sit above another harness. Hermes centers persistent memory and reusable skills. There is no honest overall winner because these projects draw the product boundary in different places.

What is an AI agent harness?

A model turns input tokens into output tokens. On its own, it does not open your repository, run a test, remember yesterday's task, or wait for your approval.

Now give an agent this job:

Find the login bug, fix it, run the tests, and report what changed.

The software around the model must decide which files enter the context window, describe the available tools, convert the model's reply into a real command, capture the result, and send that observation back. It also needs rules for retries, permissions, persistence, delegation, and stopping.

That surrounding runtime is the agent harness:

An agent harness turns model outputs into a controlled sequence of context, actions, observations, memory, and feedback.

“Harness” is a useful category, but not a strict industry standard. One project uses the word for a thin tool loop. Another includes a terminal UI, sandbox, memory, subagents, cloud service, or messaging gateway. The useful question is therefore not “Does it have a harness?” It is “What does this system own?”

What makes DeepSeek Harness different?

DeepSeek introduced Harness on August 13, 2026 as an MIT-licensed developer preview. The preview label matters: its own repository warns that breaking changes should be expected. Its documented status supports studying and building on the architecture; it does not promise the stability of a general-availability product.

Its architectural idea is more important than its current feature count.

1. “Everything is a plugin” includes the loop

Many agent products support plugins at the edges: add a command, tool, hook, or integration while the central runtime stays fixed. DeepSeek Harness goes deeper. Its architecture documentation describes the model adapter, agent loop, tool registry, session log, filesystem, execution providers, compaction, subagents, and user surfaces as composed plugins.

A profile selects a product experience. Bundles add coordinated groups of plugins. Patch layers change the assembly for a particular deployment. The shipped Web UI and headless one-shot runner are profile compositions, not the definition of the runtime.

2. Model-visible state must be logged

DeepSeek Harness treats an append-only session event log as the source of truth. If something reaches the model, it should be reconstructable from that log. Resume, fork, transcript rendering, persistence, and telemetry can then project different views from the same event history.

That is a more explicit state model than “save the chat messages somewhere.” It is useful when several front ends, storage backends, or workers need to agree on what the agent actually saw.

3. Providers can move the execution environment

The project divides a capability into three roles: a definition, a provider, and a consumer. The Bash tool consumes the shell seam; its executor, the persistent terminal backend, and the language-server host consume the subprocess seam. Point the filesystem and subprocess providers at the same remote environment, and Bash, terminal, and language-server operations move there together without separate remote implementations.

The cost is real. More replaceable parts mean more concepts, configuration, lifecycle rules, and opportunities for incompatible combinations. DeepSeek Harness is compelling when you want to build or research an agent runtime. It is less compelling if you simply want the shortest route from a prompt to a finished code change.

The Web UI exposes part of that architecture through four built-in agent presets. Our guide to the four DeepSeek Harness modes explains what Standard, Code, Minimal, and Creator change, along with the jobs each preset fits. This article stays at the product level and compares DeepSeek Harness with the alternatives around it.

DeepSeek Harness vs Claude Code

Claude Code is a first-party coding product available across the terminal, IDE, desktop, browser, and remote surfaces. Anthropic exposes CLAUDE.md instructions, skills, MCP servers, hooks, plugins, subagents, and an Agent SDK. Experimental agent teams are disabled by default. In the CLI, sessions can be resumed or branched. Checkpoints can rewind conversation plus changes made through Claude's file-edit tools, but not changes made through Bash commands or external processes.

Anthropic documents those extension points around a shared agentic loop; its public extension docs do not present the core loop or session store as user-replaceable plugins. DeepSeek Harness exposes more of that center as a plugin graph.

• Choose DeepSeek Harness when the loop, event model, providers, or interface must be replaceable parts of your own agent product.
• Choose Claude Code when you want an integrated Claude coding workflow and prefer configuring extensions over assembling the runtime.

DeepSeek Harness vs Codex

Codex combines a local CLI with an SDK, App Server, IDE extension, desktop app, and cloud workflows. AGENTS.md, skills, MCP, hooks, plugins, and subagents customize its behavior. App Server exposes persistent threads and turns to other applications, including operations to resume or fork threads.

Codex's center of gravity is operational control: explicit approval and sandbox policies, noninteractive automation through codex exec, and protocols for embedding the coding agent elsewhere. OpenAI publishes the CLI, SDK, and App Server source; the official page lists the IDE extension and Codex cloud as not open source.

DeepSeek Harness goes further in decomposing the runtime itself. Codex gives you a defined coding runtime with multiple surfaces and embedding protocols; DeepSeek gives you a framework for replacing the loop, session model, execution providers, and surfaces that define such a product.

• Choose DeepSeek Harness to experiment with or build the agent runtime.
• Choose Codex to use, automate, or embed an established coding runtime with explicit execution controls.

DeepSeek Harness vs pi: composable kernel or minimal loop?

pi calls itself a minimal terminal coding harness. Its default agent begins with four tools—read, write, edit, and bash—and supports interactive, print/JSON, RPC, and SDK use. The /tree command branches in place while preserving the history in one JSONL file; --fork copies a selected active path into a new session.

The omissions are deliberate. pi does not bundle MCP, subagents, permission popups, planning, todos, or background bash as default product features. Its README points users toward extensions, packages, containers, or tools such as tmux. Extensions can register tools and commands, change the UI, listen to lifecycle events, and connect remote operations.

So both projects are extensible, but in opposite directions:

• pi protects a small, understandable center. You add decisions around it.
• DeepSeek Harness decomposes the center itself. You assemble the loop, state, providers, and surfaces.

Choose pi when you want to understand and reshape a compact coding loop. Choose DeepSeek Harness when you need several coordinated implementations of the runtime itself.

OpenClaw vs Hermes: control plane or learning agent?

OpenClaw begins with a long-running Gateway. It connects chat channels and devices, owns routing and session identity, schedules background work, and delivers results. Its plugin registry can extend channels, tools, providers, services, Gateway endpoints, and agent harnesses. The agent-harness API is experimental and limited to bundled or trusted native plugins.

OpenClaw can put another coding runtime below the Gateway in two ways. Its bundled Codex plugin embeds the official Codex App Server, the documented default Codex path. Its separate ACP agent support runs Claude Code and other external harnesses; Codex uses ACP only when that route is explicitly selected or the native plugin cannot serve the requested operation. In either arrangement, OpenClaw owns channel routing and delivery while the delegated runtime owns its native loop and tools.

Hermes Agent also has a multi-channel Gateway, tools, subagents, MCP support, scheduled work, and several execution backends. Its distinctive default workflow is the loop between experience and persistent state. Hermes can search earlier sessions, maintain bounded memory files, and create or revise skill files that describe reusable procedures.

The documented “self-improving” loop changes bounded memory and skill files; the official docs describe no online weight-training step. Those writes can be approval-gated, but both memory and skill approval are off by default, so incorrect saved state can affect later sessions unless the operator enables review.

The cleanest distinction is:

• OpenClaw organizes where an agent is reached and how work is routed.
• Hermes organizes how one persistent agent recalls experience and turns it into reusable procedure.

Both now cover some of the other's territory. OpenClaw has durable memory and consolidation; Hermes has messaging adapters and a Gateway. These are centers of gravity, not exclusive feature claims.

The comparison that matters: where does each draw the box?

The table below separates what ships as the product's center from what can merely be added.

Imagine the same request arriving in Telegram: “The login page broke. Fix it, run the tests, and tell me when it is safe to deploy.”

• OpenClaw is most naturally responsible for receiving the message, choosing the session, routing the work, keeping it alive, and returning the answer. It may delegate the actual code task to another harness.
• Claude Code is most naturally the integrated worker that reads the repository, edits the code, runs commands, and presents the result in its established workflow.
• Codex is also the coding worker, with particular emphasis on how the command is sandboxed, approved, automated, or represented through a thread/turn protocol.
• pi supplies a small tool loop; an extension or surrounding system defines the Telegram connection, isolation, and larger workflow.
• DeepSeek Harness lets a product builder choose which plugins provide the interface, loop, session storage, filesystem, sandboxing, and delegation.
• Hermes performs the task with its own loop and may later record a durable memory or update a skill for handling similar failures.

That is why a feature-count winner would be misleading. In a real system, two of these products may be layers in the same stack rather than alternatives.

Security is a configuration, not a badge

Every system here can eventually execute model-proposed actions. “Has permissions” or “has a sandbox” is therefore too shallow a comparison.

Claude Code and Codex separate the decision to approve an action from the mechanism that limits what the resulting process can reach. Both expose modes that materially change the protection. DeepSeek Harness models approval and sandboxing as separate capabilities too; its sandbox documentation is explicit that filesystem policy is not a blanket promise about network or process visibility.

pi makes a different trade: it has no built-in per-action permission or sandbox system, and its project-trust prompt controls whether project-local settings, packages, and extensions load. Its tools otherwise run with the permissions of the user account and process unless you add isolation. OpenClaw treats each Gateway as one trusted-operator domain, and sandboxing is off by default, so main-session tools run on the Gateway host unless it is configured. Its experimental Fleet feature supports multi-tenant hosting by running a separate isolated Gateway cell per tenant. Hermes can execute directly on the host; choosing Docker, SSH, or a remote backend changes the isolation boundary.

The honest questions are concrete:

• Which directories can the process read and write?
• Is network access allowed?
• Which actions pause for approval?
• What happens if the sandbox runner is unavailable?
• Can a plugin execute arbitrary host code?
• Are several untrusted users sharing one long-lived agent?

Do not choose a system because one security-related checkbox is green. Choose a configuration whose failure mode you understand.

A local harness is not automatically local AI

This distinction matters especially on AICanRun. A harness may run on your Mac while sending every prompt to a cloud model. It may use a local model but execute tools in a remote container. It may keep code local while sending telemetry or search queries elsewhere.

Five separate questions hide inside the word “local”:

A local process is useful, but it is not a privacy guarantee. The same separation already applies when choosing a local model, runtime app, and device; an agent adds tools, state, policy, and execution locations to that stack.

Which one should you choose?

Choose by the job you are trying to own, not by the longest feature list.

For many developers the answer will be two layers. An OpenClaw Gateway may route a request to its native Codex App Server integration or an external ACP harness. A custom interface may embed Codex through App Server. DeepSeek Harness's subagent provider seam can likewise delegate a turn to another process or harness instead of running every child inline. A team may prototype a new loop in pi, then need the stronger product composition and event model of DeepSeek Harness. “Which one?” is sometimes the wrong question; “Which layer?” is better.

The early verdict on DeepSeek Harness

DeepSeek Harness deserves attention because it turns usually hidden implementation decisions into named, replaceable parts. It is not the first extensible agent, and “plugin” alone is not new. The deeper move is making the loop and durable state participate in the same composition system as tools, providers, and interfaces.

That makes it most interesting to framework authors, internal AI platform teams, and researchers who want to replace more than a prompt or tool. It does not yet make it the obvious choice for someone who wants a coding assistant to work immediately.

The release also makes one broader lesson easier to see:

Model choice determines part of an agent's intelligence. Harness design determines the world that intelligence is allowed to inhabit.

How we checked

This comparison was checked on August 14, 2026 against official documentation and the source trees for DeepSeek Harness, Codex, pi, OpenClaw, and Hermes Agent. Anthropic's public Claude Code repository does not contain the core runtime source, so we used its current product documentation as the authority. We did not rely on third-party mirrors to describe Claude Code internals.

This is an architecture and operational-fit comparison, not a benchmark. We did not compare answer quality, speed, or token use because those results would require the same model, task, context, tools, permissions, and hardware. Fast-moving counts such as stars, plugins, models, and channels are intentionally omitted.

---

DeepSeek Harness is a developer preview and all six projects are changing quickly. Re-check the linked documentation before making a security or platform decision.