R021 · Infrastructure for agents at scale › Agent session hosting and control planes

DeepSeek's Super-agent: one router, a ticket per task

Read the original

agent-platformsmulti-agentagent-governanceagent-harnessagent-workflowshuman-oversight

In short

The post's claim: the bottleneck in agentic coding has moved from what one agent can do to how many sessions one person can follow, so hand the coordination to a long-lived agent. One Router session listens to chat, issues, pull requests and CI, decides which events are real requests, gives each task an isolated Worker, and speaks only when it needs a decision or has a result. DeepSeek published a reference implementation, deepseek-ai/dsh-superagent-prototype (MIT, version 0.1.0), with an accompanying article, Exploring Super-agent Design, dated 1 November 2026 in press coverage.

Verdict. The pattern itself is not new: a dispatcher in front of isolated workers is a job scheduler, and one commenter says so. What makes the repo worth reading is its domain model for authority, not the topology. It separates who may start work (a deterministic gate plus an immutable Mandate per task) from what reaches a running task (subscriptions that deliver context but grant nothing). It also writes down rules that most agent orchestrators leave implicit: when a resumed task needs re-authorisation, when a follow-up belongs to an existing worker, and when an event creates new work. The post oversells two things: the code ships no Watchdog for loops or drift, and the headline numbers come from press reports of the article, not from the repo.

Sources: the post and its comments, and the repo's README, SETUP and design documents. The headline figures come from three press write-ups of the article.

How the prototype is built

The repo maps the post's Router onto a main Session (orchestrator in code) and its Workers onto Executor Sessions, one per Ticket, each in its own directory (typically a git worktree). It runs as a plugin bundle on DeepSeek Harness (dsh), DeepSeek's open-source agent runtime, and talks to GitHub and, optionally, Feishu. Its design docs are written as a domain model, and the domain is about authority more than about scheduling.

Only the gate grants authority; subscriptions only add contextSourceGitHub, Feishu eventsdrops own and dup eventsThreadTriggers in time orderone Eval at a timeEval (main Session)gate: code decides whoassessment: model judgesTicket + Mandatescope, strength, policy ver.immutable; wider = new TicketExecutorown Session + directoryreports ready or blockedTriggerbatchaccept(ignore: recorded)fan-out: context,no new authorityAssignmentreplies viaChannel
dsh-superagent flow · 5 concepts, two paths into a Ticket

A Trigger reaches work by one of two paths. The Eval path decides whether new work starts: a deterministic gate checks the sender against the Source's allowed list and admission table, then the model assesses the batch against the team's written rules. The Subscription path carries every later message on a Ticket's Threads (review comments, CI, bot output) straight to its Executor as context, without granting new authority.

ConceptWhat it isThe rule that matters
SourceGitHub or Feishu event stream with its own bot identityKeeps a read position so a restart never replays; drops the bot's own messages before they enter
ThreadTriggers in time order, defined by the Source (an issue, a PR, a chat topic)At most one Eval runs on it at a time; Triggers that arrive meanwhile join the next batch
EvalGate (code) then assessment (model)Gives explicit strength only to an allowed person addressing the agent; bots on a bot list can only make inferred candidates
MandateWhat an accept grants: policy version, scope, strength, matched rules, senderImmutable. Wider scope needs a new Ticket. Revalidated against the current policy before an ended Ticket resumes
TicketOne unit of authorised work, created only by EvalEnds when every PR it opened is closed; a person's later comment resumes it under the same Mandate, with no new Eval
ExecutorA dsh Session plus directory per TicketOwns follow-ups on its own Threads; hands back once anything outside its scope

Three mechanisms carry most of the design:

Execution details that a staff engineer would look for are specified: a concurrency limit on worker slots with one reserved slot so a person's message can always reach a running Ticket; foreground shell commands moved to the background after 5 seconds so a worker sees new messages at its next step; a 30-minute cap on background work after a turn; transient model or network failures retried three times with backoff; and a restart that tells each interrupted worker to check its directory, git history and GitHub before repeating any outside action.

Where the post and the code disagree

Post saysWhat the repo shows
A Watchdog session checks Workers on a schedule for loops and driftNo such component in the code or docs. The only scheduled check is an hourly status probe, run from the operator's own dsh profile, that restarts the service if it is down: liveness, the thing the post says the Watchdog goes beyond. Stalls are bounded structurally instead (a 30-minute cap on background work, blocked or failed Reports that hold a Ticket for a person, manual retry). The README says some designs in the article are future directions and not implemented; the Watchdog is probably one of them, though the README doesn't list which
A cheap rule-based filter runs before the LLMTrue, but its job is authority, not cost. The gate decides who may start work and at what strength, and message bodies or quoted documents cannot change that. That is the real defence against an injected "please also delete the repo" in an issue comment
Sessions become an implementation detailTrue. A Ticket defines its own state and may outlive several Assignments and Sessions
Install @deepseek-ai/dsh@0.2.1-rc.3The bundle declares dsh ^0.2.1-alpha.2. Both are pre-releases of a runtime in public preview, and the repo's own open questions include pinning the agent to its own dsh install so upgrades elsewhere don't break it
"Start with a sandbox repo"The right advice, and the repo is blunter: Executor Sessions run commands without approval as the operator's OS user, and the command wrappers "establish defaults, not a security boundary"

Numbers. None are in the repo. Press coverage of the article reports two: a person can supervise about 3 to 5 agent sessions at once, and one test task finished in just under 16 minutes against more than 29 minutes for a conventional workflow. Reporters note the article gives no quality measure and no task-set detail, so treat both as anecdotes.

The best comment is answered by the docs. Chris Gonzales asks how the Router avoids a review comment and a CI failure spawning two workers on one task. In the prototype, both arrive on the PR's Thread, which the Ticket already subscribes to, so they fan out to the existing Executor and never reach Eval. Accepting the same Trigger twice creates one Ticket. Duplicates across different Threads are left to the model, which sees every Ticket on the Thread during assessment; that part is judgement, not a hard rule.

Tradeoffs and failure modes

Review checklist

For anyone building or buying a Router/Worker agent:

  1. Is "who may start work" decided by code, from the event's trusted metadata, and never by the message body?

  2. Does each task carry an immutable grant (scope, requester, policy version), and is it rechecked before a stopped task resumes?

  3. Do follow-ups on an existing task reach that task without a new authorisation decision, and is that path unable to widen scope?

  4. Can proactive (unrequested) work run in a record-only mode first?

  5. When policy changes, are in-flight decisions discarded and affected tasks told, rather than silently continuing or being killed?

  6. What detects a worker that is busy but making no progress? If the answer is "a person looking at the panel", say so.

  7. Who checks a result besides the worker that produced it?

  8. Can a person always reach a running task when all worker slots are busy?

  9. After a crash, does each worker check git and the remote before repeating an outside action?

Connections

See R021 on the knowledge map

Part of the Research notes on nowucca.com. Figures and claims are the source's own unless the summary says otherwise.