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.
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.
| Concept | What it is | The rule that matters |
|---|---|---|
| Source | GitHub or Feishu event stream with its own bot identity | Keeps a read position so a restart never replays; drops the bot's own messages before they enter |
| Thread | Triggers 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 |
| Eval | Gate (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 |
| Mandate | What an accept grants: policy version, scope, strength, matched rules, sender | Immutable. Wider scope needs a new Ticket. Revalidated against the current policy before an ended Ticket resumes |
| Ticket | One unit of authorised work, created only by Eval | Ends when every PR it opened is closed; a person's later comment resumes it under the same Mandate, with no new Eval |
| Executor | A dsh Session plus directory per Ticket | Owns follow-ups on its own Threads; hands back once anything outside its scope |
Three mechanisms carry most of the design:
Accept modes for proactive work.
off,observe(the default) andauto. Inobserve, the agent assesses unrequested work against team rules and records "would accept" without doing it, so a team can review its judgement before turning it on. Explicit requests work in every mode.Policy versioning. Rules, accept mode and each Source's allowed list form one version. A change discards running Evals and requeues their Triggers, and sends a notice only to the live Tickets it affects. It never cancels running work.
Attention as the budget. The stated principle is "take as little human attention as possible." The agent acknowledges once, stays quiet while it works, and writes again only with a result, a structured question or a failure. The panel lists only what waits for a person.
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 says | What the repo shows |
|---|---|
| A Watchdog session checks Workers on a schedule for loops and drift | No 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 LLM | True, 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 detail | True. A Ticket defines its own state and may outlive several Assignments and Sessions |
Install @deepseek-ai/dsh@0.2.1-rc.3 | The 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
Parallelism moves the bottleneck to review. A commenter makes the point the post skips: more workers means more PRs to read and integrate. The prototype's answer is attention discipline (one acknowledgement, silence, then a result) and default manual merge. Its optional auto-merge is limited to approved PRs under 200 changed lines, enabled by an account other than the agent's. Nothing in it checks whether a result is correct; that is left to CI and reviewers.
The Executor grades its own work. A worker reports
readyand a person reviews. There is no independent reviewer or test author between the two, so a weak or self-written test suite passes straight through (see R020).Stuck workers depend on people noticing. Without the advertised Watchdog, a worker that loops inside its turn is bounded only by its own model's turn limits and the 30-minute background-job cap. A
blockedorfailedTicket waits for a human retry. At high concurrency, those Tickets pile up on the panel.Prompt text is policy for everything the gate doesn't cover. Who may start work is code. What the agent may do with an accepted Ticket (merge conditions, commit identity, review etiquette) is editable prompt text. The docs say so plainly, which is honest, but it means a careless prompt edit widens behaviour with no code review.
One repository, one agent account. The prototype listens to a single GitHub repo. Identities on different Sources are never mapped to each other in code (a Feishu user and a GitHub login are linked only by prompt text), which is safe but makes cross-tool requests clumsy.
Complexity is real. The domain needs Source, Trigger, Thread, Correlation, Channel, Policy, Eval, Mandate, Ticket, Assignment and Subscription, plus rules for hand-back, release and revalidation. Setup is long enough that the repo ships a SETUP.md for a coding agent to run with you. Most teams would adopt the concepts before the code.
Review checklist
For anyone building or buying a Router/Worker agent:
Is "who may start work" decided by code, from the event's trusted metadata, and never by the message body?
Does each task carry an immutable grant (scope, requester, policy version), and is it rechecked before a stopped task resumes?
Do follow-ups on an existing task reach that task without a new authorisation decision, and is that path unable to widen scope?
Can proactive (unrequested) work run in a record-only mode first?
When policy changes, are in-flight decisions discarded and affected tasks told, rather than silently continuing or being killed?
What detects a worker that is busy but making no progress? If the answer is "a person looking at the panel", say so.
Who checks a result besides the worker that produced it?
Can a person always reach a running task when all worker slots are busy?
After a crash, does each worker check git and the remote before repeating an outside action?
Related entries
R019 (s3 swarms): opposite ends of coordination. s3 trains coordination into the weights with no orchestrator; the Super-agent writes it all down as a hand-designed domain model.
R020 (model proposes, harness enforces): the gate and Mandate are harness in Theys's sense; the
readyReport and its tests are not.R005, R006: the gate layer ("who sorts") and the permissions term, built out in detail.
R016: the person's role here is adjudicator of questions and reviewer of PRs, close to R016's auditor.
R015: most of the system is deterministic workflow; the model decides only assessment and the work itself.