One org chart for everything is the bug
Graph Engineering pattern 1 of 15: the Manager–Worker Star. When independent subtasks want maximum parallelism and minimum protocol — and the hidden-coupling failure that kills it.
Most multi-agent frameworks ship exactly one org chart: a supervisor fans tasks out to workers and collects results. It is a fine architecture. It is also one architecture — and the space of organizational problems is much larger than the space it fits.
Context for new readers: rysh is an agentic terminal multiplexer — fleets of agents run as real, observable terminal sessions. This article opens a 15-part series on Graph Engineering: designing an agent organization as a graph, where agents and humans are nodes and communication, delegation, review, escalation and reporting are typed edges. The thesis of the whole series fits in one sentence: companies should not be given one universal multi-agent architecture; they should engineer the topology of their AI organization. Pattern 1 is the simplest useful shape — and the one worth understanding precisely because every framework defaults to it.
The problem it actually fits
A bounded piece of work that splits cleanly into independent parts: a migration touched in many places, documentation across a codebase, repetitive implementation. The cost of the work is in the doing, not the coordinating. When that is true — and only when that is true — the star wins.
The topology
Manager
/ | \
W1 W2 W3 ... Wn
delegation flows down the spokes
results flow back up
A manager decomposes the task into N independent subtasks, delegates each to a worker, and assembles the results. When reporting is left implicit the structure is a pure DAG; drawn explicitly, it becomes a directed star with return edges. Either way the defining property holds: workers do not talk to each other.
That absence is not an omission. It is the design. Because subtasks do not interact, worker-to-worker edges would buy coordination cost and correlated mistakes, and nothing else. One decomposition decision, N independent executions, one assembly decision — maximum parallelism with minimum protocol, and the easiest topology to reason about, monitor and bound.
The assembly step is a real job
A manager that merely staples results together is not assembling; integration failures pass silently. The manager's assembly step must be a verification step — did the parts actually compose into the thing that was asked for?
Where it breaks
- Hidden coupling. The most common failure: subtasks that looked independent were not. Two workers edit the same interface, the star has no lateral edges to reconcile them, and the collision surfaces at assembly — late. If subtasks interact, the work wants an integration node (pattern 4 in this series), not a star.
- Manager as bottleneck. Every decision routes through one node. For small N that is a feature; past a dozen workers it is pattern 10's problem, and the answer is hierarchy.
- Assembly by concatenation. See above — a stapler is not a verifier.
The dimension answers
| Dimension | Answer |
|---|---|
| Nodes | 1 manager, N workers |
| Edges | Delegation down; results back; no lateral edges |
| Cycles | None |
| Humans | Optionally review the final assembly |
| Exit rule | All workers reported; the manager's assembly check passes |
Where rysh fits
The graph property the star depends on is isolation, and that is a platform primitive, not a prompt: in rysh you spawn a fleet of agents from files on disk, each in its own git worktree, so they cannot overwrite each other. That is file isolation, stated as such — each agent works on its own checkout, which is exactly what N parallel workers need. And because every agent is a real session in its own pane, the star is watchable: you can look at any spoke, at any time, and see what it is doing.
Honest scope
- The star is a design pattern, not a product feature — what rysh ships is the primitives: panes, spawn-from-files, worktree isolation, pane addressing.
- Worktree isolation is isolation of files on your machine — not containers, not sandboxes, not remote execution.
- rysh is open-core: the CLI is Apache-2.0, the server is proprietary. It runs on Claude, with your own key.
Next in the series: pattern 2, the Investigator–Fixer Loop — where forbidding cycles means forbidding the work.
Building this with design partners → rysh.ai/design-partner