Axis Technologies
Back to blog

Super Agents

Super Agents: One Agent, Many Workers

What DeepSeek's design gets right, and what the headlines missed

AI models can now work for hours. People can still only follow a few sessions at once. A super agent is a design for that new bottleneck: one agent you talk to, and a team of workers you never have to watch.

16 min read
  • Super Agents
  • Agentic AI
  • Multi-Agent Systems
  • AI Software Development
Share

A super agent is one always-on AI agent that you talk to, backed by isolated workers that do the actual work. It watches the places your team already uses, such as chat, GitHub and monitoring tools, decides what needs doing, and only interrupts a person when a decision or a result needs them.

The term took off on 31 October 2026, when the DeepSeek Harness team published a design article and an open-source prototype called dsh-superagent. Within days the videos arrived, many of them calling it a "Claude Code killer".

It isn't one. It's something more useful: a clear answer to a problem anyone running several agents has already felt. We went through the coverage, the repository and the numbers. Here's what's worth taking from it, including the parts the headlines skipped.

Figure 1A pile of sessions or one super agent?

A pile of sessions

You are the router

  • You type a prompt to start each task
  • You remember which tab is doing what
  • Every question waits on you
  • Context from different tasks mixes in your head
  • Close the laptop and everything stops

One super agent

The system is the router

  • Events from your tools can start work
  • One agent keeps track of all the work
  • It asks one clear question, only when needed
  • Each task runs in its own isolated worker
  • It stays online when you don't
Section

The bottleneck has moved from the model to you

A year ago, the limit was what a model could do. Today's models can finish long tasks with little supervision, so teams open more of them: one session for a feature, one for a bug, one for a review.

Then they hit a different wall. DeepSeek's estimate is that a person can usually follow only three to five active sessions. Past that, you forget which tab is doing what. You spend your day switching, re-reading and answering questions. You've become the project manager, the message bus and the shared memory for your own tools.

More MCP servers and more CLIs don't fix that. They make each session stronger, but you're still the one holding them together.

So the repository's guiding principle isn't about speed at all:

Take as little human attention as possible, and give as much value as possible.

Everything else in the design follows from that sentence.

Section

Four things a super agent has to be

DeepSeek describes four traits. Together they're a good test for whether something is a super agent or just a chatbot with extra tabs.

  • Continuous. Whether you reach it in GitHub, chat or email, it feels like the same agent, and it doesn't lose the thread.
  • Productive. It works on several tasks at once and can still answer you while they run.
  • Proactive. It doesn't wait to be asked. It watches what's happening and acts within rules your team has written.
  • Persistent. It's always on. You can message it from a plane and the work still moves.
Section

The core idea: split talking from working

There's a trade-off at the heart of this. Send everything to one agent and it knows everything, but it can only do one thing at a time and all the details get mixed up. Give every task its own agent and they run fast in parallel, but none has the full picture, and you're back to switching tabs.

DeepSeek's answer is to split the agent into two levels.

Figure 2Inside a super agent
  1. 01

    Triggers

    the environment

    Events replace most typed prompts. Most of them are noise.

    • chat
    • email
    • GitHub
    • Sentry
    • CI results
  2. 02

    Permission gate

    plain code, no model

    Checks who sent it and from where. Nothing written in a message can change the outcome.

    • allowed people
    • allowed bots
    • allowed channels
  3. 03

    Router

    long-lived · never does the work

    Handles all communication and decides who takes each job. A lighter, faster model is usually enough.

    • talk to people
    • accept or ignore
    • assign work
  4. 04

    Workers

    one task each · isolated

    Each gets its own context, folder, full toolset and the strongest model you can afford.

    • ticket
    • worktree
    • tests
    • pull request
  5. 05

    Watchdog

    outside the main loop

    Runs on a schedule and catches workers that are stuck, silent or drifting off the goal.

    • progress checks
    • loops
    • recovery

The router is a dispatcher who never picks up a wrench. It's a long-running session that handles every conversation and hands out work. It doesn't do the work itself, and in DeepSeek's design it can run without a shell tool at all.

Workers are the opposite. Each one gets a single task, its own context and working directory, and all the tools it needs. Workers never talk to people directly. They report back, and the router does the talking.

This might sound like a lead agent with subagents, but there's an important difference. A lead agent takes a task, breaks it into steps and stays responsible for it, so every new message interrupts it. A router only decides who handles what, which is why it stays available.

Section

What happens when a message arrives

Say a colleague writes in the team chat: "The login page is failing on mobile again."

Figure 3From event to pull request
  1. 01

    Fast path

    Code checks it

    Right person? Right channel? Most events stop here, before any model runs.

  2. 02

    Slow path

    Router decides

    Is this new work? Does it match a rule the team wrote? It records why.

  3. 03

    Dispatch

    A worker starts

    A fresh session, its own folder, one ticket, all the tools.

  4. 04

    Follow-ups

    Replies skip the router

    The worker subscribes to its thread, so comments and CI go straight to it.

  5. 05

    Attention

    A person signs off

    The agent speaks up once, with a result or one clear question.

Three details make this work better than you'd expect.

A fast path and a slow path. This is a classic computer-science pattern. Cheap code rejects the obvious noise, and only what survives reaches the expensive model. In DeepSeek's test only about 20 of 300 messages were real work, so this filter matters.

Follow-ups go straight to the worker. Once a worker owns a pull request, review comments and CI results go directly to it. The worker still has the full context, and the router doesn't have to read every comment. Without this shortcut, cached reads rose by about 37% in DeepSeek's test.

The router batches under pressure. You'd expect one router to choke when things get busy. Instead, events that pile up during one turn are handled together in the next. Going from about one event a minute to about 40, individual model calls got a little slower, from 2.5 to 3.9 seconds, but the inference time per decision fell from 6.4 to 1.6 seconds.

Section

The other building blocks

The router and workers get most of the attention, but they aren't the whole design. DeepSeek's article describes five building blocks:

  1. Two levels. The router and workers described above.
  2. Event-driven triggers. Group chats, email, calendar reminders, review comments and CI results replace most typed prompts. This also allows speculative work: under a "silently reproduce and fix" rule, a worker can try to reproduce a reported bug in the background and only speak up once it has confirmed the problem and found a simple fix.
  3. Asynchronous, multi-channel conversation. A normal agent loop blocks while it works, like a walkie-talkie. Here, the conversation in the foreground and the work in the background run at the same time, across several channels.
  4. Compute, state and environment kept apart. The agent loop can run in the cloud, session state lives in a database, and the code and credentials stay where they already are, reached through a small daemon. That avoids the pain of keeping a cloud copy of each environment in sync.
  5. An external watchdog. A long-running system can't be trusted to notice its own failures. An independent session driven by scheduled messages checks that work is really moving.

If much of this sounds familiar, that's fair. One of the videos we reviewed was openly a little disappointed that a frontier lab's big reveal was mostly well-known engineering. We see that as the most reassuring part. Batching, fast paths, watchdogs and separating compute from state are decades old, and they still work when the thing being scheduled is an AI model.

Section

What the numbers really say

The figure that went everywhere was "almost twice as fast". It's a real number, but it needs context.

Figure 4DeepSeek's test at a glance
Slowest tasks (p95) with a super agent
15.7 min
Slowest tasks (p95) with a single session and neutral prompt
29.5 min
Typical task (p50) with a single session told to delegate first, against 12.4
13.8 min
Cached tokens read, compared with the neutral single session
3.8×

Here's the full comparison, as reported from DeepSeek's article. It's published in Chinese, so we're relying on detailed English summaries of its tables, which matched each other:

SetupMedian task (p50)Slowest tasks (p95)Cached tokens per run
Super agent12.4 min15.7 min23.23M
Super agent, without direct follow-ups12.6 min15.5 min31.77M
Single session, neutral prompt20.4 min29.5 min6.05M
Single session, "delegate first" prompt13.8 min29.0 min10.82M

Three things stand out:

  • It wasn't a test of coding. Each run replayed about 300 chat and CI messages, around 20 of them real requests, with timings compressed to a quarter of real time. The coding itself was a placeholder tool that simply waited. It measures coordination, not code quality, and the authors call the results preliminary.
  • The neutral single session never delegated. In five runs it didn't call its subagent tool once. So "twice as fast" largely compares a system that shares out work with one that was never told to.
  • A one-line prompt closes most of the typical gap. Telling the single session to delegate first removes about 6.6 of the 8 minutes separating it from the super agent at the median. That's over 80% of the gain, with no new architecture.

But the prompt doesn't fix everything, and this is the part we find most interesting. The p95 barely moved, at 29.0 minutes. In one of the five runs, the model decided the work was small enough to do itself, and that one choice caused the long tail.

So a good prompt improves the typical case, while the architecture protects you from the bad one. When delegation is a rule of the system instead of a choice the model makes each time, you get predictable finish times. Whether that predictability is worth the complexity is the real decision.

The bill comes from re-reading

Every model call re-sends the conversation, and most of it is served from the provider's cache at a reduced rate. A router that stays alive and wakes for each event, plus a set of workers with their own context, re-reads a lot: about 23 million cached tokens per run, against 6 million for the neutral session.

The same design can cost very different amounts depending on where you run it. One detailed cost breakdown priced those reads at about $0.07 on DeepSeek's Flash model and about $4.65 on Claude Opus 5.5, per simulated day. It also points out something easy to miss: an always-on agent is idle most of the time, so how long the cache lasts can matter as much as its price. If your router's cache expires over lunch, it pays to rebuild it. Prices change often, so run this calculation with current rates.

Section

What to check before you install anything

DeepSeek is unusually direct about the risks in its own docs. Take these seriously.

  • It's a research prototype. The README says it's "for reference only, not an official DeepSeek product". The published code differs from what DeepSeek runs internally, and some ideas in the article aren't implemented.
  • Full access by default. The deployment guide states that router and workers run with danger-full-access as your OS user, and that a worker can read your home directory. Its advice is a dedicated OS account holding only the agent's credentials.
  • Prompt injection is built into the job. This agent exists to read text written by other people. Issues, comments and chat messages are all potential instructions from someone you don't trust. Nobody has fully solved this yet.
  • Know where your data goes. In DeepSeek Harness, the session-log plugin defaults to on. On requests to DeepSeek's official API, it can send message text, tool arguments and results, and workspace paths. It doesn't apply if you use another provider, and there's a setting to turn it off. Check what your profile actually does before the agent starts reading team chat. For European companies, that content can include personal data, so have the GDPR conversation first.

To be fair, the defaults around acting are careful. Proactive work starts in observe mode, which only records what the agent would have done. The agent account won't enable auto-merge by default, and the default instructions only allow it for approved pull requests under 200 changed lines, on a separate merge account. Those instructions guide the agent rather than enforce anything, so use GitHub branch protection as well.

Some of the most practical advice came from a creator who rebuilt a small version: Docker as a non-root user, no access to home or SSH keys, a bot account limited to one sandbox repository, a host command that checks every message the agent posts, and no ability to merge its own work. It's a good minimum for any experiment.

Section

Who actually needs this?

Figure 5Is a full super agent worth it for you?

Probably not yet

A good prompt gets you most of the way

  • One developer on one repository
  • No stream of requests to sort through
  • An agent already open, and you're happy to watch it
  • No one available to own and review the agent's output
  • Tasks that need human judgement at every step

Worth a serious look

Someone is working as the human router

  • Several developers, or several agents running at once
  • A busy chat with small requests scattered through it
  • Someone currently filtering and assigning all of that by hand
  • Mostly small, reviewable changes
  • A named person who owns what the agent says and does

The honest test: is someone on your team losing hours to triage? If not, a delegate-first prompt may be all you need today.

The creator who rebuilt it said the same thing plainly: for a solo developer with an agent already open, the gain is small. The coding doesn't get better. What changes is that you have a quiet teammate running in the background. And as one benchmark of 68 real GitHub bugs mentioned in the coverage suggests, the harness may make a smaller difference than the difficulty of the bug itself. A super agent improves how work is coordinated. It won't make your model any smarter.

Section

It's not only about code

The public prototype is a coding agent for one GitHub repository, but we think the pattern will travel well beyond software.

Think about a shared customer inbox, or an operations team juggling ERP alerts, supplier emails and chat requests. Someone reads everything, drops most of it, and passes the rest to whoever can handle it. That person is doing the router's job.

The same split would apply: code filters what the agent is allowed to look at, a router decides what's real, workers each handle one case with the right tools and limits, and people approve anything involving money, customers or safety. An AI gateway fits naturally underneath, giving the router a small, fast model and the workers a stronger one.

This is our own view rather than something DeepSeek has tested, and it should be proven on a small scale first. But the problem is the same: human attention is the scarce resource, and most of it goes on sorting.

Section

Start with three small changes

The best part of all this is that you don't need DeepSeek, its harness or a big rebuild. Most of these ideas work with whichever model and tools you already use.

1. Add a delegation-first instruction. If your agent keeps doing everything itself, tell it to hand parallel work to subagents before it starts. It costs almost nothing, and it's where most of the median gain came from.

2. Put a gate written in code in front of the model. Before any model reads a message, ordinary code should check the sender, the channel and the type of message. It saves money, and more importantly, nothing inside a message can talk its way past it.

ts
// lib/gate.ts (simplified)type Decision = 'request' | 'candidate' | 'drop';export function admit(event: TriggerEvent, policy: Policy): Decision {  if (!policy.channels.includes(event.channel)) return 'drop';  const allowed = policy.people.includes(event.sender);  if (allowed && event.addressesAgent) return 'request'; // a clear ask: work on it  if (allowed) return 'candidate'; // let the model check it against written rules  return 'drop'; // never reaches a model, so it can't inject anything}

3. Keep follow-ups with the worker that owns the task. Send review comments and CI results to the session that already has the context, instead of through your coordinator or into a new session. You avoid paying to rebuild that context, and your coordinator stays lean.

If those work and you still feel like the bottleneck, go further:

Figure 6Growing into a super agent
  1. 01

    Specify

    Write real tickets

    Workers can't ask you things, so each ticket says what to build and how to check it.

  2. 02

    Split

    Router and workers

    The router assigns and never does the work. Each worker gets its own worktree.

  3. 03

    Watch

    Add a watchdog

    A separate agent on a timer catches stuck or silent workers.

  4. 04

    Observe

    Record, don't act

    Let proactive rules log what they would have done, and read those logs.

  5. 05

    Widen

    Earn more autonomy

    Turn on one rule at a time, once its recorded decisions look right.

Tickets deserve special attention, because the design depends on them. One team that rebuilt this inside Claude Code gave every feature a folder with two files: one describing the requirements and one listing the checks that define "done". The router could then check a worker's results against those checks, and only go to a person when there was a real decision to make. In their run, three tickets were built in about an hour. It's one anecdote, not a benchmark, but the lesson holds: autonomy starts with clear specifications.

They also ran a stronger model as the router and a mid-tier one as workers, because the tickets were so detailed. That's the opposite of DeepSeek's advice, and that's fine. The split is the idea. The model choice is a setting you can tune.

Section

The short version

A super agent isn't a new kind of AI, and it isn't a Claude Code killer. It's an architecture built on one honest observation: models can now work for longer than people can keep track of them.

The human doesn't disappear in this picture. You move up the chain, away from babysitting sessions and towards deciding what's worth building, writing the rules and signing off on results.

If you're running one agent, change the prompt. If someone on your team has become a full-time human router, the full design is worth exploring, carefully and in a sandbox.

We build this kind of system for real business workflows, with the permissions, logs and human approvals it needs to be trusted. If your team is drowning in agent sessions or in requests that someone has to sort by hand, have a look at our agent-powered software development service or get in touch. We'll tell you honestly whether you need a super agent or just a better prompt.

Sources and further watching: DeepSeek's dsh-superagent repository and docs, and the videos that shaped this article: Rob Shocks on DeepSeek's super agent and rebuilding it for Claude Code, AI LABS on a working Claude Code setup, lustoykov on the design article's building blocks and Kai on the benchmark and the real costs.

Found this useful? Share it with your team.

Super agent FAQ

Frequently asked questions about super agents

What teams ask us once they start running more than a couple of agents at the same time.

Let's Build Something Amazing Together

Ready to transform your business with cutting-edge digital solutions? Our team of experts is here to bring your vision to life.