Super-agent

Built on the Super-agent design.

In 2026 DeepSeek Harness published Exploring Super-agent Design, with a reference prototype. In November 2026 Mission Control's core was rebuilt around it. This page covers what was taken, what was changed, and how it runs today.

Mission Control is an independent Python implementation, not a port of the prototype, and is not affiliated with or endorsed by DeepSeek.

The idea

Most agents are one conversation that does everything: it talks, it runs the tools, and while it works, nothing else gets its attention. The Super-agent design splits those apart. To the person there is one agent, always reachable, that always knows what is going on. Behind it, separate sessions do the work.

  • A coordinator and workers. One session reads what arrives and decides. Workers each take one task and act on it.
  • Events and subscriptions. Everything that happens is an event on a thread. A worker can follow a thread and hear what concerns its task directly.
  • Asynchronous by default. Nobody blocks on slow work. A worker is woken when what it is waiting for arrives.
  • State apart from the loop. What a task knows lives outside any one process, so work survives a restart.
  • A watchdog. Something outside the work checks that the work is really moving.

The article is candid about what it leaves open: memory, scale, where one context ends and another begins, and security.

How Mission Control adopted it

In the designIn Mission Control
The coordinatorThe Router: one long-lived session and the agent's only voice. It reads events in batches, answers, starts tasks and hands follow-ups to them. It has no shell. server/router.py
WorkersOne isolated session per task, with a specialist's tools and instructions, run in parallel with a place always kept for you. server/workers.py
Events and threadsEvery message, comment, CI run and schedule is recorded once, with its thread and a visible outcome. A worker that follows a thread gets its events with no decision spent. server/triggers.py
Asynchronous workSlow commands move to the background and wake the worker when they end. Watches poll a build or a deploy until it settles.
State apart from the loopTranscripts, tasks, reports and the event log are kept in one local database. A restart picks every task up where it was.
The watchdogA watchdog inside checks every session is getting somewhere, and a small one outside can restart the app if it stops answering. server/watchdog.py

Where it departs

  • It runs on your Mac, not in the cloud. State is already separate from the loop, so a restart resumes, but when the Mac sleeps, the agent sleeps.
  • No remote shell. Work for another machine goes to the Mission Control on that machine, which has its own agent and its own hands. Nothing new on the network can run commands.
  • A local noise filter reads first. Events from outside get a free read on your machine that may only drop what it is sure is noise.
  • Direct lines. Write to a specialist by name and you reach it directly, in that chat, without the coordinator in between.
  • Workers do not start workers. A worker that needs someone else hands the task back, and the coordinator starts them.

What it added

Running the design every day, on real repositories and real messages, showed where a coordinator and workers need firmer ground than a prompt.

  • Authority in code. What a task may do depends on who started it: you, a job you set up, or an outside event. Never on what a model concludes. Outward commands from work you did not ask for wait for your approval, shown in full.
  • Outward actions happen once. A push, deploy or message is remembered for an hour, across restarts and across workers, so a retry cannot repeat it.
  • Done means confirmed. Work you asked for has a finish line, what you asked for as checks, and cannot be reported finished until each is confirmed. A task that stops short asks you rather than being filed as done.
  • Waiting has to be real. A task may only wait on something that will wake it. Watches test their check before they start, stop when it keeps failing, and end with their task.
  • Answers say how fresh they are. The coordinator sees when each task last reported, and asks the task rather than repeating an old report as current.
  • Working copies. One task at a time holds a repository's checkout. Another that needs it gets a copy-on-write clone, so no task works on top of another's changes.

Like the article, Mission Control treats security as unfinished. Its rules are defence in depth, not a sandbox: workers run as your user, on your Mac.

How it works today

  1. Arrive

    Recorded

    Every event, once, with its thread. Who sent it decides what it may start.

  2. Decide

    The Router

    Answers, starts a task, or hands a follow-up to the task it belongs to.

  3. Work

    Workers

    In parallel and in isolation, waiting only on what will wake them.

  4. Report

    To you

    A confirmed result, or the one decision only you can make.

The complete design, with each rule and the incident behind it, is in docs/super-agent.md. For the everyday view, see How it works.