Every LLM agent framework reinvents process management. Isolation between agents, resource limits, composition of subtasks, lifecycle management — these are solved problems. The operating system kernel has provided them for fifty years.
Note (2026-11-12; read against the paper's full text): the paper says its contribution is a concrete runtime design point and not a replacement for existing frameworks, and makes no claims about superior end-task performance; the reference implementation's host is about 3,100 lines of Go and exposes four tools (sh, fork, exec and exit) to the model. The essay's statements about what the design eliminates (thousands of lines in existing frameworks) and that most of the code of agent frameworks reimplements the kernel are not claims I found in the paper; the paper's own list of what frameworks reconstruct includes fault isolation simulated with exception handlers and context switching handled in the application, and it discusses where the process model stops (task-relative worlds and revisable time).
Quine maps agent concepts directly onto POSIX abstractions: identity is PID, interface is stdin/stdout/exit code, state is memory and filesystem, lifecycle is fork/exec/exit. A single executable recursively self-spawns. Each agent instance is a genuine OS process with kernel-enforced isolation, scheduling, and inter-process communication.
No orchestrator sits above the agents. The shell is the orchestrator. Pipes compose agents. Environment variables pass configuration. Exit codes signal success or failure. The agent framework is the operating system — the one already running.
What this eliminates: application-layer reimplementations of scheduling, sandboxing, message passing, and lifecycle management that occupy thousands of lines in existing agent frameworks. What it inherits: decades of kernel-level hardening, debugging tools, resource controls.
The limitation the authors acknowledge is cognitive: POSIX processes model execution, not reasoning. The missing abstractions — task-relative worlds, revisable time — are specifically about cognition, not computation. The process model gives you everything about running agents and nothing about thinking agents.
The architecture reveals what agent frameworks actually do: most of their code reimplements the kernel, and the remainder — the small part about reasoning — is what actually needs to be built.