linux/unix

This work addresses the architectural redundancy in existing LLM agent frameworks, which reimplement isolation, scheduling, and communication mechanisms already provided by modern operating systems. The paper proposes modeling LLM agents directly as POSIX processes, uniquely identified by process identifiers (PIDs), with interfaces and state defined through standard streams, exit statuses, and the file system. By leveraging native system calls—fork, exec, and exit—the framework enables a lightweight, recursively self-replicating runtime that inherits kernel-enforced isolation and resource control. This design natively supports shell-composable workflows, exec-driven context resets, and recursive delegation, while also exposing inherent limitations of the process model for cognitive tasks. An open-source reference implementation demonstrates the potential of leveraging OS-native capabilities to build secure, composable LLM agents.

The lack of formal specifications for opaque Unix commands hinders the practicality of program analysis systems. Method: This paper introduces the first automated specification mining approach that synergistically integrates large language models (LLMs) with system-level instrumentation: LLMs parse unstructured command documentation to generate structured syntactic and semantic constraints; concurrent system-call and filesystem instrumentation dynamically observes command behavior across diverse environments, extracting key properties—including input domains, side effects, and error modes. Contribution/Results: Our method achieves the first end-to-end, LLM-driven specification synthesis across commands and heterogeneous documentation formats, supports multiple standard specification outputs (e.g., SMT-LIB, JSON Schema), and integrates seamlessly with static analyzers. Evaluated on 60 commands—including GNU Coreutils, POSIX utilities, and third-party tools—it attains a 98.3% specification correctness rate, fully eliminating manual specification authoring.

Existing NL2SH (natural language to Bash command) evaluation is severely hindered by low-quality test data and unreliable heuristic-based functional equivalence judgments. To address these limitations, this work proposes: (1) the first functional equivalence assessment framework integrating command execution verification with LLM-powered semantic judgment, achieving 95% accuracy; (2) the largest human-annotated NL2SH benchmark to date—comprising 600 high-quality test instances and 40,939 training samples; and (3) a model enhancement strategy combining instruction tuning, in-context learning, constrained decoding, and weight-intrinsic learning to improve generalization. Experiments demonstrate up to a 32% absolute improvement in NL2SH translation accuracy and a 16% increase in evaluation confidence over state-of-the-art methods. All data and code are publicly released.

Linux’s fragmented distribution ecosystem undermines user experience consistency, significantly impeding its mainstream adoption in consumer markets. Method: This paper proposes a “structured standardization” framework—grounded in modular ecosystem design—that reconciles beginner-friendly usability with advanced-user flexibility without compromising open-source principles. Through integrated analysis—including case studies, statistical surveys across diverse user roles (developers, designers, system administrators, gamers), and technical evaluation of modern stack components (Flatpak, Wayland, Snap)—the study systematically identifies how fragmentation differentially impacts stakeholder groups. Contribution/Results: The work provides the first empirical论证 of a viable standardization pathway that simultaneously ensures cohesive user experience and preserves ecosystem diversity. It delivers an actionable governance roadmap, offering both theoretical foundations and practical implementation paradigms to position Linux as a credible alternative to Windows and macOS.

Automated verification of interactive console I/O programs in Haskell education remains challenging due to the dynamic, history-dependent nature of student implementations. Method: We propose a lightweight, formal behavioral specification language that uniquely integrates global state and execution history, expressed via regex-like syntax; its trace-based semantics enable probabilistic testing and scalable verification through *sampleable validity*. Contribution/Results: Our system automatically validates student submissions against behavioral specifications and supports pedagogical closed-loop applications—including real-time feedback generation, example solution synthesis, and exercise randomization. Empirical evaluation demonstrates substantial improvements in test coverage and pedagogical adaptability while preserving formal rigor. To our knowledge, this is the first framework for verifying interactive behaviors in functional programming education that simultaneously achieves theoretical soundness and practical deployability.

This work addresses the limitations in maintainability, auditability, and runtime robustness of current AI agent systems, which stem from the absence of a unified resource abstraction and interaction paradigm. It systematically introduces the Unix philosophy of “everything is a file” into AI agent design, proposing a novel “files are all you need” paradigm. By leveraging file-like abstractions to unify heterogeneous resource interfaces and integrating Infrastructure-as-Code (IaC), DevOps practices, and autonomous agent architectures, the approach establishes a consistent and composable interaction model. This significantly simplifies operational semantics and yields a principled framework for designing AI agent systems that are highly maintainable, auditable, and robust, thereby offering both theoretical foundations and practical guidance for future AI infrastructure.

This work addresses the lack of effective isolation and atomic commit mechanisms in current AI agents when concurrently exploring multiple solution paths. To this end, we propose a novel operating system abstraction called “branch context,” which provides agents with isolated, nestable, and rollback-capable execution environments through a structured fork-explore-commit/abort lifecycle. We design unprivileged OS-level mechanisms that support nested branching, commit-on-first-success semantics, and automatic invalidation of sibling branches. A prototype file system, BranchFS, is implemented atop FUSE, complemented by a new Linux system call, branch(), and copy-on-write techniques. Experimental results demonstrate that branch creation incurs only 350 microseconds of overhead, with small-scale commits completing in under 1 millisecond, substantially improving both the efficiency and safety of parallel exploration.

Existing symbolic execution approaches often lack a formal foundation aligned with the concrete semantics of programming languages, typically being constructed in an ad hoc and fragmented manner. This work proposes a symbolic Structural Operational Semantics (SOS) rule format that, for the first time, relies solely on the algebraic signature of the source language to uniformly capture both concrete and symbolic operational semantics, thereby enabling language-agnostic generation of symbolic execution semantics. Within this framework, we formally derive symbolic semantics and rigorously prove their soundness and completeness relative to the concrete semantics, demonstrating applicability to arbitrary programming languages.

Traditional binary-only fuzzing predominantly relies on dynamic instrumentation due to the perceived difficulty of achieving both accuracy and performance with static instrumentation, which has consequently been largely overlooked. This work proposes PeAR, an approach that leverages existing static binary rewriting frameworks to enable efficient and precise static instrumentation, supporting modern fuzzing features such as deferred initialization, persistent mode, and shared-memory communication. Experimental evaluation on FuzzBench demonstrates that PeAR successfully instruments 88% of target programs, achieves a median throughput improvement of 4×, and matches the coverage of compile-time instrumentation. These results establish, for the first time, that static instrumentation can simultaneously deliver high performance and high fidelity while enabling complex, fine-grained instrumentation capabilities.

Existing zkVMs require statically linking custom runtimes to build unikernels for supporting modern programs, leading to version fragmentation, bloated trusted computing bases (TCBs), and redundant auditing efforts. This paper introduces ZeroOS—the first modular libOS designed specifically for zkVMs—enabling on-demand linking of Linux ABI subsets, allowing verified applications (vApps) to be built via standard toolchains without maintaining large runtime forks. Its key contributions are: (1) a zkVM-native libOS architecture supporting ABI-level dynamic trimming and cross-platform portable booting; and (2) a lightweight bootloader abstraction layer coupled with a static linking optimization framework. The open-source implementation has been integrated into multiple zkVM projects, significantly reducing TCB size, lowering maintenance overhead, and improving vApp security, auditability, and ecosystem compatibility.