Quine: Realizing LLM Agents as Native POSIX Processes

• URL: http://arxiv.org/abs/2603.18030v1
• Date: Sun, 08 Mar 2026 05:32:46 GMT
• Title: Quine: Realizing LLM Agents as Native POSIX Processes
• Abstract summary: This paper presents Quine, a runtime architecture and reference implementation that realizes LLM agents as native POSIX processes.<n>The mapping is explicit: identity is PID, interface is standard streams and exit status, state is memory, environment variables, and lifecycle is fork/exec/exit.<n>A reference implementation of Quine is publicly available on GitHub.
• Score: 0.6700873164609007
• License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/
• 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.

Related papers

• FRAMEWORKERS: A Dynamic Multi-Agent Framework for AI-Generated Video Production [55.71860113185132]
  We introduce FRAMEWORKERS, a task-centric and workspace-grounded multi-agent framework for open-ended video production.<n>A central Director formulates video creation as dynamic task management, continuously editing a Task Stack to determine which subtask to execute next and which sub-agent to invoke.<n>An Assistant serves as the execution layer, grounding each selected task in a shared Workspace, retrieving the required assets and context, invoking the assigned sub-agent, and persisting the resulting artifacts.<n>Experiments show that FRAMEWORKERS outperforms strong planners in routing accuracy, recovers reliably from runtime failures, generalizes to unseen sub
  arXiv  Detail & Related papers  (2026-08-30T14:28:50Z)
• DeepRepro: State-Aware Subplanning for Paper-to-Code Reproduction in Evolving Repositories [116.27249583403871]
  We propose a state-aware framework for paper-to-code reproduction based on execution-state-aware subplanning.<n>DeepRepro transforms evolving repository states and runtime feedback into fine-grained implementation subplans.<n>Experiments on PaperBench Code-Dev show that DeepRepro consistently outperforms strong scientific and commercial code-agent baselines.
  arXiv  Detail & Related papers  (2026-08-27T02:54:30Z)
• Towards an Agent Operating System - Lessons from Classical and Cloud OS [1.694273347265762]
  Agentic AI systems are currently in the experimentation phase of the third such wave.<n>No community consensus exists on what the core abstractions are or what guarantees they carry.<n>We argue that the path forward is to follow the prior-wave methodology.
  arXiv  Detail & Related papers  (2026-07-27T21:10:59Z)
• PhyAgentOS: A Self-Evolving Operating System for Embodied Agents with Decoupled Cognitive Planning and Physical Execution [49.776611937968]
  We present PhyAgentOS, a foundation delivering scheduling, verification, memory, benchmarking, and safety as system-level services.<n>Its Session-Centered treats a session, not an action, as the minimum unit of scheduling, compatibility, supervised execution, evidence collection, and acceptance.<n>SessionVerifier distinguishes execution termination from semantic task completion via evidence-grounded verdicts of success, failure, or replan.<n> Benchmarking reuses the deployment session and verification path, so results trace to real execution.
  arXiv  Detail & Related papers  (2026-07-18T04:46:53Z)
• A Formal Hierarchical Architecture for Agentic Orchestration with Stack-Based Execution and Lazy Discovery [5.106901034158075]
  This paper presents a hierarchical, skill-based architecture for agentic orchestration.<n> Capabilities are organized as a rooted tree where internal nodes make routing decisions and leaf nodes execute deterministic tasks.<n>By replacing global memory with localized stack frames, the architecture prevents outputs from one execution branch from leaking into another.
  arXiv  Detail & Related papers  (2026-07-13T06:15:51Z)
• Agent libOS: A Library-OS-Inspired Runtime for Long-Running, Capability-Controlled LLM Agents [0.6345523830122165]
  Large language model (LLM) agents are evolving from request-response assistants into long-running software actors.<n>This paper presents Agent libOS, a library-OS-inspired runtime substrate for LLM agents.
  arXiv  Detail & Related papers  (2026-06-02T16:53:24Z)
• Syll: Open-Source Personal Automation with Cross-Surface Execution [73.77463150026068]
  We present Syll, an open-source, self-hosted multimodal agent harness.<n>Syll unifies MCP/API tools, CLI execution, and visual control in a modular runtime.<n>Our implementation has been validated on production desktop applications including Adobe Photoshop, Adobe Audition, Stardew Valley, Finder.
  arXiv  Detail & Related papers  (2026-05-28T17:59:31Z)
• Deterministic Replay for AI Agent Systems [0.0]
  AI agent systems that couple large language models with external tools and APIs are inherently non-deterministic.<n>Existing observability platforms capture execution logs but cannot reproduce a run in isolation.<n>We present a developer-first CLI framework for deterministic replay of agent executions.
  arXiv  Detail & Related papers  (2026-04-30T12:00:45Z)
• Interpretable Context Methodology: Folder Structure as Agentic Architecture [0.0]
  Current approaches to AI agent orchestration typically involve building multi-agent frameworks that manage context passing, memory, error handling, and step coordination through code.<n>This paper presents Model Workspace Protocol (MWP), a method that replaces framework-level orchestration with structure.<n>Plain markdown files carry the prompts and context that tell a single AI agent what role to play at each step. Local scripts handle the mechanical work that does not need AI at all.
  arXiv  Detail & Related papers  (2026-03-17T00:03:23Z)
• ANCHOR: Branch-Point Data Generation for GUI Agents [52.22377425487]
  End-to-end GUI agents for real desktop environments require large amounts of high-quality interaction data.<n>We present a trajectory expansion framework Anchor that bootstraps scalable desktop supervision from a small set of verified seed demonstrations.<n>Experiments on standard desktop benchmarks, OSWorld and WindowsAgentArena, show that models fine-tuned on our expanded corpus achieve consistent improvements.
  arXiv  Detail & Related papers  (2026-02-06T19:55:26Z)
• From Everything-is-a-File to Files-Are-All-You-Need: How Unix Philosophy Informs the Design of Agentic AI Systems [0.0]
  A core abstraction in early Unix systems was the principle that 'everything is a file'<n>This paper explores how an analogous unification is emerging in contemporary agentic AI.
  arXiv  Detail & Related papers  (2026-01-16T03:40:28Z)
• Monadic Context Engineering [59.95390010097654]
  This paper introduces Monadic Context Engineering (MCE) to provide a formal foundation for agent design.<n>We demonstrate how Monads enable robust composition, how Applicatives provide a principled structure for parallel execution, and crucially, how Monad Transformers allow for the systematic composition of these capabilities.<n>This layered approach enables developers to construct complex, resilient, and efficient AI agents from simple, independently verifiable components.
  arXiv  Detail & Related papers  (2025-12-27T01:52:06Z)
• Towards Agentic OS: An LLM Agent Framework for Linux Schedulers [3.8068085728995307]
  We introduce SchedCP, the first framework that enables fully autonomous Large Language Model (LLM) agents to safely and efficiently optimize Linux schedulers without human involvement.<n>Our evaluation shows that SchedCP achieves up to an 1.79x performance improvement, and a 13x cost reduction compared to naive agentic approaches.
  arXiv  Detail & Related papers  (2025-09-01T08:38:49Z)
• PC-Agent: A Hierarchical Multi-Agent Collaboration Framework for Complex Task Automation on PC [98.82146219495792]
  In this paper, we propose a hierarchical agent framework named PC-Agent.<n>From the perception perspective, we devise an Active Perception Module (APM) to overcome the inadequate abilities of current MLLMs in perceiving screenshot content.<n>From the decision-making perspective, to handle complex user instructions and interdependent subtasks more effectively, we propose a hierarchical multi-agent collaboration architecture.
  arXiv  Detail & Related papers  (2025-02-20T05:41:55Z)
• Commit0: Library Generation from Scratch [77.38414688148006]
  Commit0 is a benchmark that challenges AI agents to write libraries from scratch.<n>Agents are provided with a specification document outlining the library's API as well as a suite of interactive unit tests.<n> Commit0 also offers an interactive environment where models receive static analysis and execution feedback on the code they generate.
  arXiv  Detail & Related papers  (2024-12-02T18:11:30Z)
• DynaSaur: Large Language Agents Beyond Predefined Actions [126.98162266986554]
  Existing LLM agent systems typically select actions from a fixed and predefined set at every step.<n>We propose an LLM agent framework that can dynamically create and compose actions as needed.<n>In this framework, the agent interacts with its environment by generating and executing programs written in a general-purpose programming language.
  arXiv  Detail & Related papers  (2024-11-04T02:08:59Z)

This list is automatically generated from the titles and abstracts of the papers in this site.

This site does not guarantee the quality of this site (including all information) and is not responsible for any consequences.