跪拜 Guibai
← All articles
AI Programming · AIGC

Router-Worker Architecture Moves an AI Workbench From Session Firefighting to a Task Board

By LV技术派 ·
Read original on juejin.cn ↗ Google Translate ↗ Alt translation

Task-level orchestration with event-derived state makes unattended parallel agents practical: a solo developer can hand scheduling to a Router and still keep acceptance authority. The constraint is that whichever Worker you scale has to be reliable enough to self-verify and recover, otherwise a Router just spreads errors across more sessions.

Summary

Human attention is the real limit in parallel AI pairing, not agent capability. The workbench operator caps usable parallel sessions at three; beyond that, a notification from one window gets dropped when an urgent bug pulls attention elsewhere. The fix is to manage tasks rather than sessions. A task becomes a persistent canvas that outlives any Claude Code or Codex window, holding specs, design screens, reports, and acceptance records. Task status is not stored; it's derived from a set of events the agent reports at the end of each round via canvas-agents report, such as ready, blocked, or dropped. Seven states run from unplanned to done, and a task is awaiting review whenever any of its windows is blocked waiting for human input.

The Router layer sits above tasks. A resident agent, called the Spirit Steward, receives requests from the chat window and from external triggers: GitHub issues, Feishu groups, and soon Jira. It triages, creates work orders, and dispatches sessions, but never writes code itself. It follows the Super Agent rule that state does not live in the conversation, so closing a window or compressing context never loses task progress. A human remains the only one who can mark a task done. The author argues quality must come before scale: each Worker needs to be able to define, verify, and recover on its own, and only then does a Router multiply concurrency without multiplying mistakes.

Takeaways
— The practical concurrency ceiling is 3 parallel sessions; beyond that, attention loss causes tasks to be forgotten.
— Task lifecycles are decoupled from session lifecycles: a task maintains its identity across window closures, session changes, and context compression.
— Task state is never stored; the workbench records events such as 'round started', 'answer given', and 'approval clicked', and computes state on demand from all windows.
— Seven task states exist: unplanned, to-do, in progress, awaiting review, awaiting acceptance, done, cancelled.
— A window reports each round via canvas-agents report as ready, blocked, or dropped; stopping without a report is recorded as 'stopped without explanation'.
— For multi-window tasks, the state is decided by whichever window most needs the human: blocked beats done, done beats running.
— Only a human can move a task to done; no agent report does it.
— The Router agent ('Spirit Steward') only uses canvas-agents CLI and external triggers, never writes code or passes gates.
— GitHub trigger creates to-do tasks from bugs with reproduction steps, ignores usage questions, and asks the human when descriptions are vague; acceptance auto-comments and closes the issue.
— Feishu bot accepts messages only from whitelist members; idle chat is 'read but not replied', genuine requirements spawn tasks and sessions.
— Unanswered blocked windows get a push reminder to the phone after 30 minutes.
— The system runs on Cloudflare (Workers, D1, R2, Durable Objects) and costs about $5/month.
— About 20+ skills cover brainstorming, spec-to-acceptance, prototype, high-fidelity design, code generation, test, and acceptance.
Conclusions

Keeping state out of the conversation and out of storage is what makes the difference: task identity survives any session refactor. The event-log approach is a simple, practical substitute for a dedicated state machine.

A Router that is forbidden from doing real work creates a clear control boundary: the human keeps the only acceptance privilege, which is what makes delegating scheduling to an agent safe.

The quality-first rule means concurrency is not a free win: you need Workers that can define, verify, and recover on their own, or a Router will just multiply broken outputs across many sessions.

Concepts & terms
Router-Worker architecture
A pattern from DeepSeek Harness's Super Agent paper where a Router agent only schedules and dispatches work to Worker agents; the Router never does the work itself.
Event-derived task state
Instead of storing a task's current status, the system records events such as 'round started', 'answered', and 'approved', and computes the task status on demand from the latest events of all its sessions.
External trigger
A webhook or bot integration (GitHub issue, Feishu group, Jira) that feeds new requests directly to a Router agent, which creates a task or assigns it to an existing session.
AI delivery quality triangle
The author's three-question test for automation-worthiness: the definition is correct, the verification is correct, and failure is recoverable.
Source: juejin.cn ↗ Google Translate ↗ Backup ↗