[论文解读] Quine: Realizing LLM Agents as Native POSIX Processes

Hao Ke|arXiv (Cornell University)|Mar 8, 2026

Mobile Agent-Based Network Management被引用 0

一句话总结

该论文提出 Quine，一种运行时在本地 POSIX 进程中实现 LLM 代理的运行时，采用递归的单图像运行时，将代理概念映射到操作系统原语，并通过主机-来宾架构将认知委托给托管的 LLM。

ABSTRACT

Current LLM agent frameworks often implement isolation, scheduling, and communication at the application layer, even though these mechanisms are already provided by mature operating systems. Instead of introducing another application-layer orchestrator, this paper presents Quine, a runtime architecture and reference implementation that realizes LLM agents as native POSIX processes. The mapping is explicit: identity is PID, interface is standard streams and exit status, state is memory, environment variables, and filesystem, and lifecycle is fork/exec/exit. A single executable implements this model by recursively spawning fresh instances of itself. By grounding the agent abstraction in the OS process model, Quine inherits isolation, composition, and resource control directly from the kernel, while naturally supporting recursive delegation, context renewal via exec, and shell-native composition. The design also exposes where the POSIX process model stops: processes provide a robust substrate for execution, but not a complete runtime model for cognition. In particular, the analysis points toward two immediate extensions beyond process semantics: task-relative worlds and revisable time. A reference implementation of Quine is publicly available on GitHub.

研究动机与目标

• Argue that the OS can serve as the runtime substrate for LLM agents by mapping agent identity, interface, state, and lifecycle to POSIX primitives.
• Provide a reference single-image runtime that realizes agents as native POSIX processes with recursive delegation.
• Analyze the reach and limits of the POSIX process model for cognition and identify extensions beyond process semantics (world and time).

提出的方法

• Define a disciplined mapping from agent concepts to POSIX primitives across identity, interface, state, and lifecycle.
• Implement a unitary Go executable that serves as both runtime and agent template with recursive self-instantiation.
• Adopt a host-guest architecture separating deterministic control (host) from probabilistic cognition (guest).
• Expose tools sh, fork, exec, exit as the primary interaction interface.
• Maintain a 5-channel I/O contract (argv, stdin, stdout, stderr, exit status) tied to POSIX streams and exit codes.
• Demonstrate POSIX conformance via file descriptor mappings and shell-level compositions.

实验结果

研究问题

• RQ1 Can LLM agent lifecycles be realized purely through POSIX process semantics without external orchestration?
• RQ2 What level of isolation, composition, and continuity does the OS process model provide for cognitive agents?
• RQ3 What are the immediate extensions beyond process semantics needed to support agent worlds and revisable time?
• RQ4 How does a single-image runtime enable recursive delegation and shell-native composition of agents?
• RQ5 What are the practical limits of the POSIX model for cognition as evidenced by operational demonstrations?

主要发现

• Agents realized as native POSIX processes yield kernel-enforced containment, composition via recursive delegation, and continuity through exec-based context renewal.
• A host-guest architecture separates deterministic control from probabilistic cognition, with the host managing state and I/O while the guest handles reasoning and tool calls.
• The runtime supports standard shell composition and pipelines, enabling three illustrative shell patterns and reflexive external invocations as ordinary POSIX commands.
• A 3,100-line host plus 2,600-line provider layer yields a ~9.8 MB single binary supporting multiple LLM providers.
• Operational validations show recursive delegation (a 3-level tree with 36 sessions) and exec-based context renewal (up to 9 cycles in MRCR-style tasks) with improved reproducibility when streaming context.
• The architecture highlights boundaries of POSIX for cognition, notably world-scoping and revisable time, suggesting future design directions beyond traditional process semantics.