The first correspondence is the one everything else stands on: a branch of parallel agent work is a process. It is born with a purpose and a slice of the world, it runs without knowing its siblings' internals, it consumes a metered resource, and it ends — reporting a result, or failing, or being killed. An orchestrator is a scheduler, and it inherits, whether it wants them or not, a scheduler's obligations.
Start with isolation, the obligation schedulers learned first. A process gets its own address space not because processes are elegant but because they are dangerous: any of them may be buggy, and the system's survival cannot depend on all of them being right. Branches are isolated for the same reason. A branch that wanders writes its confusion into its own context and its own artifacts; its siblings' worlds are not addressable, so its error has nowhere to spread. The systems that skip isolation — one shared context, everyone editing — rediscover why the address space was invented, at token prices.
The cosplay detour
The industry's first attempt at parallel agents deserves a section here, because it violated every term of this chapter at once. The early multi-agent frameworks forked nothing: one model, run serially, inside one shared transcript, with the "workers" differentiated by system prompts assigning them job titles — a product manager, an engineer, a QA lead, in costume. Different argv[0], same binary. There was no address space to protect, because there was only one memory. There were no artifacts, because the workers communicated by chatting in character. There were no exit statuses, because nobody designed a return contract — only a group conversation that eventually stopped. What got parallelized was the self-introduction, not the work. Specialization is real, but it lives in state, tools, contracts, and objectives — not in a title a model is asked to perform. The cosplay era survives as a control experiment: possessing none of the load-bearing parts, it shows exactly which parts were load-bearing.
Then the machinery of the pool. Work stealing — idle workers pulling tasks from busy workers' queues — is how schedulers balance load they cannot predict, and it is how a branch pool should treat a task graph whose branch costs are unknown until run. Preemption asks its uncomfortable question: may a long branch be interrupted, and what is saved when it is? A branch that cannot be checkpointed cannot be preempted; it can only be killed and charged. And the resource is metered, which makes scheduling an economic act: priorities are claims about value, and a pool without priorities spends its budget in arrival order — the one order guaranteed to know nothing about value.
Finally, the deaths nobody budgets for. A zombie branch has finished, but nobody collected its result; the table fills with the completed and unread. An orphan is worse: the coordinator died — session closed, deploy restarted, human walked away — and the branch runs on, consuming real money against a task nobody is waiting for. Operating systems reap orphans by adoption or by kill, but never by forgetting they exist. Agent systems forget constantly, because their process tables are implicit. Make the table explicit: every branch registered, owned, metered, and reaped. It is the least glamorous sentence in this series and the one that will save the most money.