DeepSeek Super-Agent vs. Claude Code and Codex: 6 Dimensions to See Whether the Difference Lies in the Model or the Orchestration System

Author’s note: Now that DeepSeek has open-sourced its Super-agent research prototype, how does it really differ from Claude Code and Codex? This article compares them across six dimensions, separating model, coding tool, and orchestration capabilities to help you choose a setup for your workflow.

On October 31, 2026, the DeepSeek Harness team published a technical article, “Exploring Super-agent Design: Toward More Autonomous Agent Systems,” and open-sourced the accompanying dsh-superagent-prototype on its official GitHub under the MIT license. Its two-tier orchestration architecture with a persistent Router and independent Workers quickly sparked discussion. Bloomberg, the South China Morning Post, and other outlets covered it in the context of competition with Claude Code and Codex.

This isn’t another article taking sides over who’ll replace whom. The repository explicitly labels the project a research prototype, and Claude Code and Codex have long since moved beyond single-session tools. When comparing DeepSeek Super-agent with Claude Code and Codex, the more useful question is: Do the differences come from the underlying model or from the agent’s orchestration system?

What you’ll take away: By the end of this article, you’ll understand which layer each offering belongs to, what DeepSeek’s design choices mean in practice, and how to choose the right combination of tools for your workflow.

DeepSeek Super-agent at a Glance

Let’s start by defining what it is—and what it isn’t. DeepSeek Super-agent isn’t a new foundation model. It’s an agent system architecture built around a Large Language Model, and what’s publicly available today is a research prototype, not a commercial product.

As of November 2, the project page showed around 8,900 Stars and 898 Forks, though those numbers are still changing. It’s worth emphasizing that Stars only indicate interest—they don’t tell us how many people have installed the project or how often it succeeds at coding tasks.

What Problem Is DeepSeek Super-agent Trying to Solve?

The DeepSeek team starts with an interesting observation: as models get better at individual tasks, the efficiency bottleneck is shifting from model capability to human attention. Based on its own experience, the team believes one person can usually follow only about 3–5 active agent sessions effectively. That’s because context is scattered, people have to switch windows frequently and manually issue the next instruction when a task ends, tool calls can block sessions, and tasks can be interrupted when a local device goes to sleep.

That 3–5 session figure is the DeepSeek team’s experience-based estimate, not an industry statistic. But it makes Super-agent’s research direction clear: the goal isn’t to make the model smarter, but to shift session scheduling, event handling, and context management from the person to the system. The team has set out four target characteristics: Continuous, Productive, Proactive, and Persistent. These are design goals, not a claim that the prototype has fully achieved them.

DeepSeek Super-agent vs. Claude Code and Codex: First, Understand the Three Layers

Before asking “which is better,” it’s important to recognize that these three don’t sit at exactly the same product layer. Claude Code and Codex are coding agent products with their own tool ecosystems. Super-agent focuses on an outer layer around agents: an always-on, event-driven system for coordinating multiple tasks. The actual reasoning and tool execution still depend on the underlying model and DeepSeek Harness.

That means the comparison has three layers: model capability determines the quality of individual reasoning steps and code generation; coding tool capability determines whether an agent can read and write files, run tests, and submit PRs; and orchestration system capability determines how multiple tasks are received, assigned, tracked, and delivered. Mixing these layers together can easily lead to misleading conclusions.

The table below compares publicly available capability mechanisms across six dimensions. Note that it compares mechanisms, not performance rankings under identical conditions.

Each row matters for a different reason. “Single-task coding” shapes your day-to-day coding experience. “Event triggers” and “background operation” determine whether agents can work without you watching. “Context management” affects whether tasks interfere with one another as their number grows. And “deployment cost” directly affects whether a team is willing to invest the time to get started.

Claude Code’s Multi-Agent Capabilities Are No Slouch

According to Anthropic’s official documentation, Claude Code Subagents have independent context windows. You can give them dedicated system instructions, restrict their access to tools, and assign different models. They can also handle research and some implementation tasks in parallel in the background. The experimental Agent Teams feature goes further: a Lead and multiple Teammates each run as independent Claude Code sessions, share a task list, and can message one another directly. The feature is disabled by default, and Anthropic warns that it increases coordination overhead and token consumption.

For events and ongoing operation, claude-code-action can respond to @claude mentions in Issue and PR comments and, with the right configuration, turn an Issue into a PR. Channels, available as a research preview, use MCP to push chat messages, webhooks, and CI results into a running session, though the session must stay active. There’s also the in-session /loop command, scheduled tasks in the desktop app, and cloud-scheduled tasks. Some tasks can continue in the cloud after your computer is turned off. So the idea that “Claude Code can only passively wait for input” is already outdated.

Codex Multitasking: Separate the Product From the API

Codex can use Git Worktrees to create multiple independent working directories for the same project, letting different sessions modify different branches in parallel. Codex Cloud analyzes code, implements changes, and runs tests in isolated workspaces. Cloud tasks can continue even after your computer is turned off. The ChatGPT/Codex ecosystem also supports scheduled background tasks, as well as triggers from app events such as GitHub events and PR activity filtering for eligible users.

There’s an easy point of confusion here: the multi-agent capabilities offered by the OpenAI Agents API and Responses API—such as a main agent delegating to subagents with independent contexts—are API capabilities. They shouldn’t be taken as default features across all Codex product interfaces. Similarly, the OpenAI Cookbook’s example of “using GitHub Actions to call the Codex CLI and generate a fix PR after a CI failure” is a way to build a workflow, not a built-in Codex CLI feature that works out of the box.

Router + Worker Orchestration in DeepSeek Super-agent

The core workflow of the DeepSeek prototype can be summarized as Source → Trigger → Eval → Ticket → Assignment → Executor → Result. Events arrive from GitHub or Feishu and pass through deterministic rules for permission filtering. A model then decides whether a task should be created. Each accepted task gets its own Ticket and is assigned to a Worker with an independent working directory. The result is returned through the original channel, such as a GitHub PR.

The Router is a long-running primary session that receives messages, maintains global context, decides whether to create tasks, checks authorization, and assigns and tracks work. As a rule, it doesn’t handle complex coding. According to the official documentation, this means the Router can sometimes use a lighter model to reduce orchestration costs. Workers receive clearly defined tickets, write code in isolated directories, run tests, handle follow-up feedback, and submit results.

The Real Difference: How DeepSeek’s Super-agent Scheduling System Is Designed

Claude Code and Codex already have multi-agent, background, and event capabilities. So what sets DeepSeek apart? The answer isn’t whether those capabilities exist—it’s who manages the work and how much they manage.

A conventional lead agent that delegates subtasks, or an Agent Team’s Team Lead, is usually deeply involved in planning, coordinating, and merging results for one complex task. DeepSeek’s Router focuses instead on high-level coordination across tasks: one always-on Router manages multiple, relatively independent work items at once. Users interact with one logical Super-agent through their usual channels, such as GitHub and Feishu, without having to manage each Worker session themselves.

DeepSeek also acknowledges that an Agent Team’s lead agent can form a similar two-layer architecture if it’s configured to handle only global interactions and delegation, without executing tasks itself. Router + Worker isn’t an exclusive capability that others can’t replicate. The real difference is how systematically always-on listening, cross-task routing, and a unified work context are brought together. That shows up in three ways:

• Always-on Router: It runs as a long-lived primary session rather than a coordinator launched for each task, so global context can carry across tasks.
• Direct event subscription: A Worker subscribed to a Thread can receive subsequent events directly, such as new comments on the same PR, reducing repeated delegation by the Router.
• Conservative proactivity: Tasks are classified as Explicit (direct requests) or Inferred (potential work identified from context). Inferred work defaults to observe mode, where it’s recorded but not executed. Automatic PR merging is also off by default.

How to Read DeepSeek’s Official Super-agent Experiment Results

DeepSeek ran a set of synthetic scheduling experiments. Each run had about 300 messages, roughly 20 of which were work requests; the rest included casual conversation, follow-up feedback, cancellations, and CI messages. Programming work was replaced with simulated tools that took time to run, and each setup was tested five times.

Two findings are especially useful. First, compared with the single-session setup that prioritized delegation, Super-agent had only a small P50 advantage, but a much shorter P95 tail. That suggests the main benefit of the two-layer architecture is avoiding long delays when many tasks are in flight. Second, removing direct event subscription barely changed completion time, but increased cache reads from about 23.2 million to about 31.8 million. Its main benefit, then, appears to be reducing repeated processing by the Router rather than speeding things up.

There are important limits, though: this was a scheduling experiment, not a code generation quality test. The comparison groups were single Session + Subagent setups using specific prompts—not full Claude Code or Codex products tested under the same conditions. The results therefore don’t prove a 39% or 47% improvement in real-world programming efficiency, and they certainly can’t be used to rank the three products by speed. A separate official Router batch-processing test found that at around 40 events per minute, the average batch grew to 2.8 events and amortized reasoning time fell to 1.6 seconds per decision. That, too, only demonstrates viability under the tested workload.

DeepSeek Super-agent’s Cost and Security Boundaries

Speed comes at the cost of more tokens. In synthetic tests, Super-agent’s cache-read volume was about 3.8 times that of the neutral single-session approach. But that doesn’t mean the total cost is 3.8 times higher. The final bill also depends on model pricing, cache hits, input and output token volumes, and which models the Router and Workers use. DeepSeek hasn’t published an average cost per real-world ticket.

For reference, here are DeepSeek’s official API prices as of November 2, 2026 (USD per million tokens). These are model rates, not Super-agent subscription prices:

Search and Fetch each cost $0.75 per 1,000 successful requests, with billing starting November 1, 2026, at 00:00 Beijing time. These charges apply only when the services are actually called. Deployers also need to account for server resources, ongoing operating expenses, and manual maintenance. Claude Code and Codex, meanwhile, offer different plans involving subscriptions, API usage, and cloud execution. There’s currently no consistent “cost per qualifying PR” metric for comparing all three.

💰 Cost management tip: In a multi-agent architecture, the key cost question is which model each role uses. If you want to experiment with a lightweight model for the Router and a more powerful one for the Workers, you can use APIYI at apiyi.com to access multiple leading models with a single API key. Pay-as-you-go billing makes it easier to track token costs for different combinations on one bill.

Security matters just as much. The official deployment documentation acknowledges that the dedicated Router and Worker presets run in danger-full-access mode and, by default, execute as the operator’s system user. That means they may be able to read files in the home directory, run local programs, and access local credentials. The documentation recommends using a separate system user and a separate GitHub bot account. Monitoring external comments and messages also introduces prompt injection risks. A third-party audit report in the community has flagged potential issues, including management interface validation, in commit 6337fc8. However, the full attack sequence hasn’t been independently reproduced, so these should be treated as potential risks rather than incidents that have occurred.

DeepSeek Super-agent Impact Analysis

Impact on Developers

• Evaluation criteria need to evolve: When choosing a tool, don’t just look at the underlying model’s scores. Consider whether its event integration, task isolation, background execution, and human review mechanisms fit your team’s workflow.
• The prototype works, but it’s not hassle-free: Community user xxxxkkkqq successfully moved an issue through to a PR in a private repository, but encountered missing notifications, messages that didn’t arrive despite passing deployment checks, and test assertion failures caused by a Chinese system language setting. Another user found two defects within an hour on WSL2: one involving Node.js 24 process detection and another involving missed GitHub comments.
• There’s clear value in building on it: For teams that can maintain TypeScript, GitHub integrations, and model APIs, this is a complete reference implementation covering the Router, events, tickets, Workers, and permission rules.

Impact on the Industry

• Competition is shifting beyond models: AI coding is no longer just a model-versus-model contest. Agent Harnesses, workflow design, and developer experience are becoming equally important factors.
• “Proactive Agents” are becoming more structured: DeepSeek ties “proactive work” to authorization policies, observe mode, and human acceptance, addressing the practical concern that Agents might waste a team’s attention.

Based on these capabilities, here’s how the options stack up by working mode:

🎯 Recommendation: These tool combinations aren’t mutually exclusive. Many teams can use Claude Code or Codex for everyday coding while a custom orchestration layer handles events and routing. When building that layer, you can get free testing credits through APIYI at apiyi.com to compare how different models perform as Routers and Workers.

Recreating the DeepSeek Super-agent Router Approach with an API

The best way to understand a scheduling system is to build a minimal version yourself. The example below uses an OpenAI-compatible interface and a lightweight model to make routing decisions. It illustrates the idea only; it isn’t the actual code from the DeepSeek prototype.

import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # APIYI OpenAI 兼容接口
)

event = "PR #42 评论：CI 在 test_auth.py 失败，请帮忙看看"
resp = client.chat.completions.create(
    model="ROUTER_MODEL",  # 替换为控制台中可用的轻量模型名
    messages=[{"role": "user", "content": f"判断该事件是否需要建任务，只回答 YES/NO：{event}"}]
)
print(resp.choices[0].message.content)

import openai
from dataclasses import dataclass, field

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # 一个 Key 接入多家模型
)

ROUTER_MODEL = "ROUTER_MODEL"   # 轻量模型：负责路由判断
WORKER_MODEL = "WORKER_MODEL"   # 强模型：负责具体任务
AUTHORIZED_USERS = {"alice", "bob"}  # 确定性规则：授权名单

@dataclass
class Ticket:
    thread_id: str
    task: str
    history: list = field(default_factory=list)

tickets: dict[str, Ticket] = {}

def router_eval(event: dict) -> bool:
    """先规则过滤，再由模型判断是否建任务"""
    if event["user"] not in AUTHORIZED_USERS:
        return False  # 未授权：仅观察，不执行
    resp = client.chat.completions.create(
        model=ROUTER_MODEL,
        messages=[
            {"role": "system", "content": "你是任务路由器，只回答 YES 或 NO。"},
            {"role": "user", "content": f"该消息是否是需要执行的工作请求？\n{event['text']}"}
        ],
        max_tokens=5
    )
    return "YES" in resp.choices[0].message.content.upper()

def worker_run(ticket: Ticket, text: str) -> str:
    """Worker 使用独立上下文处理任务"""
    ticket.history.append({"role": "user", "content": text})
    resp = client.chat.completions.create(
        model=WORKER_MODEL,
        messages=[{"role": "system", "content": "你是代码修复助手，给出修复思路。"}] + ticket.history
    )
    answer = resp.choices[0].message.content
    ticket.history.append({"role": "assistant", "content": answer})
    return answer

def handle(event: dict) -> str:
    tid = event["thread_id"]
    # 订阅直通：已有 Ticket 的后续事件直接交给对应 Worker
    if tid in tickets:
        return worker_run(tickets[tid], event["text"])
    if router_eval(event):
        tickets[tid] = Ticket(thread_id=tid, task=event["text"])
        return worker_run(tickets[tid], event["text"])
    return "已记录，未建任务"

print(handle({"thread_id": "pr-42", "user": "alice", "text": "CI 在 test_auth.py 失败"}))
print(handle({"thread_id": "pr-42", "user": "alice", "text": "补充：只在 Python 3.12 下失败"}))

This example illustrates three things: deterministic rules run before the model makes a decision, the Router and Worker use different models, and follow-up events in the same thread go directly to the existing Worker’s context. A real system also needs working directory isolation, a permissions sandbox, state persistence, and human review—all areas where the prototype is still being refined.

🚀 Get started quickly: To run the code above, just replace the API key and model names. Check the APIYI console at apiyi.com for the current list of available models. New users receive free testing credits, making it easy to validate the scheduling approach at low cost before investing in further development.

Frequently Asked Questions

DeepSeek Super-agent vs. Claude Code and Codex: Key Takeaways

• Different layers: Super-agent is a scheduling system prototype, while Claude Code and Codex are coding Agent products.
• Multi-Agent capabilities aren’t exclusive: Claude Code and Codex already support sub-Agents, parallel sessions, background tasks, and events.
• The real difference is system design: An always-on Router, cross-task routing, direct subscription access, and unified context are the key design priorities.
• Experimental results have limits: Synthetic scheduling tests reflect scheduling performance only—not coding quality or a ranking of the three products.
• Speed comes at a Token cost: Cache reads are about 3.8 times those of a single-session approach. Actual costs depend on the models used.
• Security must come first: High-privilege operation and prompt injection from external inputs call for separate accounts and human review.
• Hands-on testing is more reliable: Use a single API key from APIYI apiyi.com to test a multi-model Router/Worker setup.

Summary

The main conclusions from comparing DeepSeek Super-agent with Claude Code and Codex are:

1. They operate at different layers: Model capabilities, coding tool capabilities, and scheduling system capabilities are three separate things. Comparing them as if they were the same isn’t meaningful.
2. DeepSeek’s value lies in its scheduling design: It brings always-on monitoring, cross-task routing, and unified context into a coherent system, while using permissions and observe mode to limit proactive behavior.
3. The maturity gap is real: The prototype has real-world examples of going from Issue to PR, but installation, reliability, and security still need work. Claude Code and Codex remain the safer choices for everyday coding.

Competition in AI coding is expanding beyond “which model is stronger” to include Agent Harnesses, workflows, and developer experience. For most teams, the more practical path is to use mature products for everyday coding while experimenting with a custom scheduling layer on a small scale.

We recommend using APIYI apiyi.com to access multiple leading models through a single service and quickly test their performance and costs in Router and Worker roles.

📚 References

1. DeepSeek Super-agent official prototype repository: Project status, source code, and intended use
2. Link: github.com/deepseek-ai/dsh-superagent-prototype

3. Details: Includes the README, deployment documentation, authorization mechanism, and design philosophy

4. DeepSeek API official pricing: Model pricing and Search/Fetch fees

5. Link: api-docs.deepseek.com/quick_start/pricing

6. Details: The basis for calculating Router and Worker model costs

7. Claude Code Subagents and Agent Teams documentation: Multi-agent capabilities

8. Links: code.claude.com/docs/en/sub-agents, code.claude.com/docs/en/agent-teams

9. Details: Learn about independent subagent contexts and team collaboration

10. Claude Code Channels and scheduled tasks documentation: Event delivery and continuous operation

11. Links: code.claude.com/docs/en/channels, code.claude.com/docs/en/scheduled-tasks

12. Details: Learn about the requirements and limitations of these research preview features

13. Codex Cloud and Worktrees documentation: Cloud tasks and parallel workspaces

14. Links: help.openai.com/en/articles/20001545-using-codex-cloud, learn.chatgpt.com/docs/environments/git-worktrees

15. Details: Official sources for distinguishing between Codex product features

16. OpenAI Agents API multi-agent guide: Multi-agent orchestration at the API level

17. Link: developers.openai.com/api/docs/guides/agents-api/multi-agent

18. Details: Read separately from the Codex product documentation

19. DeepSeek Harness community testing discussion: An end-to-end report from issue to PR

20. Link: github.com/deepseek-ai/deepseek-harness/discussions/11706
21. Details: Learn how the prototype performs in practice and what issues users commonly encounter

Author: APIYI Technical Team
Technical discussions: Feel free to contact us through the APIYI homepage. For more resources on multi-model integration and agent orchestration, visit the docs.apiyi.com documentation center.

Related Articles

• Magpie vs. CC Switch: My settings.json Can't Love Two People at Once: Compare magpie and CC Switch, two AI coding tool switchers: their configuration file and local gateway approaches, release cadence, recommended use cases, how five types of users should choose, and why both cannot write to the same settings.json at once.
• Step-by-Step Tutorial: Connect All Agents with One Key Using Open-Source Magpie as a Unified API Gateway (Claude Code, Codex, Pi, and Hermes Examples): A step-by-step tutorial you can complete in about 30 minutes to get every coding agent on your machine—such as Claude Code, Codex, Pi, and Hermes—using the same API key and gateway address, with Magpie interface screenshots, setup instructions, native configuration comparisons, and a troubleshooting table.
• T3 Code Getting Started Guide: Control Claude Code, Codex, and OpenCode Remotely from Your Phone in 8 Steps: For developers already using Claude Code, Codex, or OpenCode on their computers, connect coding agents to a phone in eight steps, covering remote access options, permission modes, quota pitfalls, and APIYI gateway integration.
• Gemini 4 Argon vs. Claude Opus 5.5: Breaking Down Google’s 19-Benchmark Scorecard to See Which Is Stronger Across 4 Dimensions: Based on Google’s official Gemini 4 Argon evaluation table, compare Gemini 4 Argon and Claude Opus 5.5 across 19 benchmarks in knowledge work, agentic coding, long-context tasks, and multimodal capabilities, incorporating independent evaluations from Artificial Analysis and Vals, as well as differences in pricing, output limits, and availability, to offer scenario-based model recommendations.
• Researchers Rejoice: Install 177 Research Skills with One Command and Hit the Ground Running: A step-by-step guide to integrating K-Dense-AI’s 177 research Agent Skills: review the list, install only what you need, add Python dependencies, trigger and verify them, with a troubleshooting table and risk warnings.