A series built on an analogy owes its readers a final chapter: the audit of the analogy itself. An isomorphism that cannot say where it stops is not an isomorphism; it is a mood. Here is where this one stops.
The merge is intelligent, and that changes everything downstream. A scheduler never reads what a process computed. A pipe moves bytes whose meaning is none of the kernel's business. But an agent fan-in must understand: the synthesis reads findings, weighs contradictions, and exercises judgment about which branch to believe. The coordinator in an agent system is a participant, not a mechanism. This is a genuine addition to the old design space — and a genuine cost, because the merge becomes a model call with a model's failure modes, priced and fallible, where the kernel's version was a memory copy.
The compute is heterogeneous. A CPU cycle is a CPU cycle; schedulers balance a fungible resource. A model call is not fungible with another model call: they differ in price, latency, and judgment, and routing work among them is a decision about quality, not just load. Agent scheduling is heterogeneous scheduling — closer to placing work across CPUs, GPUs, and accelerators than to the clean world of identical cores. The old vocabulary survives, but every policy built on it must be re-derived with quality in the equation.
The state cannot be fully snapshotted. A process's memory can be copied bit for bit; a checkpoint is exact. An agent's state lives partly in the record — context, artifacts, steps — and partly nowhere writable: in the trajectory of a model's attention, in what was almost said. Everything this series said about fork, preemption, and undo applies only to the recorded part. Agent systems therefore cannot inherit the operating system's guarantees; they can only inherit its structures, and rebuild the guarantees, more weakly, on the fidelity of their records.
And the deepest break: the principals are the programs. An operating system serves users who are not themselves processes. An agent orchestrator's workers and its coordinator are the same kind of thing — models all the way up — which means the scheduler can be persuaded, the workers can be prompt-injected through their inputs, and the boundary discipline of the syscall chapter must hold against adversaries who speak the system's own language fluently.
None of this dissolves the correspondence. It locates it. The operating system's answers transfer exactly as far as the problem is one of resources, isolation, and coordination — which is most of the problem, most days. What remains after that is the part with no precedent: intelligence, checking itself, in the kernel's chair. That part we will have to write ourselves.