state management

Current AI coding agents treat large language models (LLMs) as autonomous decision-makers, leading to stochastic failures—including hallucinated syntax and test failures—due to uncontrolled generation. Method: This paper proposes a neuro-symbolic system for software engineering, demoting the LLM to a controlled environment component governed by deterministic workflows. It introduces three core innovations: (1) a dual-state architecture separating workflow state from environment state; (2) atomic action pairs that couple code generation with immediate verification; and (3) guard functions mapping probabilistic LLM outputs to discrete, observable states. Contribution/Results: For the first time, it imports deterministic control paradigms from classical software engineering into LLM agent design. Evaluated across 13 models (1.3B–15B parameters), the approach improves task success rate by up to 66 percentage points, with only 1.2–2.1× increased computational overhead—achieving robustness gains through architectural refinement rather than model scaling.

This work addresses the reliability challenges of production-grade large language model (LLM) agents, which stem from the lack of a clear architectural abstraction delineating stochastic outputs from deterministic system behavior. To bridge this gap, the paper introduces the Stochastic-Deterministic Boundary (SDB) as a core architectural primitive, formalized as a four-tuple contract. Centered on three key concerns—coordination, state, and control—it defines six composable runtime modes. The contributions include a five-step methodology for mode selection, a replay-based divergence diagnosis mechanism, and the insight that architectural momentum becomes critical for long-term reliability once model variance diminishes. By integrating distributed systems patterns such as Saga and event-driven orchestration, the authors construct a verifiable, rollback-capable, and monitorable LLM agent runtime. Empirical validation across five real-world workloads demonstrates its efficacy, and a reference implementation for a 90-day contract renewal agent is open-sourced, significantly enhancing sustained operational reliability.

Traditional distributed systems struggle to support modern autonomous infrastructures that integrate stochastic models and autonomous agents. This work proposes the Post-Deterministic Distributed System (PDDS) model, introducing for the first time its five architectural pillars. Its core innovation is a "cognitive state replication" mechanism that extends consistency from data visibility to knowledge visibility, alongside a novel fault classification framework. By leveraging protocol-driven development, verifiable agent infrastructure, and semantic quorum guarantees, PDDS enables coordination among semantically equivalent yet executionally divergent agents. This approach achieves verifiable semantic rollback and cross-agent reasoning consistency, establishing a theoretical foundation for trustworthy autonomous systems.

This paper addresses discrete-time interconnected systems whose subsystem dynamics and interconnection topology are partially unknown. Method: We propose a data-driven, compositional approach to construct finite-state abstractions for formal verification and distributed controller synthesis. Subsystems are modeled individually from input-output data, and—novelly—the unknown static interconnection mapping is treated as a learnable object, enabling its symbolic abstraction. Compositionality and rigorous error propagation analysis ensure that the resulting abstraction strictly satisfies an approximate simulation relation. Contribution/Results: We theoretically establish scalability and verifiability of the abstraction. Experiments demonstrate substantial mitigation of the curse of dimensionality, enabling high-precision, low-complexity controller synthesis while preserving formal guarantees.

This paper investigates whether deterministic computation can be fully characterized by a finite algebraic system analogous to Kleene Algebra with Tests (KAT). Specifically, it addresses whether the deterministic fragment of KAT admits a finite set of control-flow operations sufficient to generate all deterministic finite-state computations. Method: Drawing on formal language theory, algebraic semantics, regular algebra, and model-theoretic techniques, the authors rigorously analyze the expressive limitations of finite algebraic signatures over deterministic automata. Contribution/Results: The paper establishes, for the first time, that no finite set of control-flow primitives can axiomatize the entire class of deterministic finite-state computations—thereby refuting the existence of a KAT-style complete algebraic framework for determinism. This result demonstrates an intrinsic incompleteness in the algebraic characterization of deterministic computation and reveals a fundamental expressiveness boundary of classical control structures (sequence, conditionals, loops), advancing foundational understanding of computational representability in program algebras.

This work addresses the lack of automated evolutionary capability in traditional hardware design flows, which hinders end-to-end autonomous optimization. The authors propose HORIZON, a novel framework that extends warehouse-scale self-evolution—previously limited to EDA tools—to the hardware design process itself by modeling design as code evolution within isolated Git working trees. HORIZON integrates Markdown-based knowledge encapsulation, executable evaluators, acceptance predicates, Git/runtime policies, and an autonomous agent loop to achieve a closed-loop, human-intervention-free hardware design evolution. Evaluated across ChipBench, RTLLM, Verilog-Eval, and nine CVDP benchmark categories, the approach achieves a 100% task completion rate, demonstrating its effectiveness in fully autonomous hardware synthesis and optimization.

This work addresses the challenges of irreproducibility, debugging difficulty, and limited reusability in long-horizon robotic systems caused by asynchronous execution of heterogeneous modules. To this end, the paper introduces Retriever—a full-stack framework that unifies the modeling of asynchronous closed-loop agents at both algorithmic and system levels for the first time. Retriever represents agents as stateful causal flow function graphs over an explicit runtime clock and formalizes their interaction with the environment as an asynchronous loop in continuous time. The framework enables deterministic orchestration, systematic cross-environment debugging, and high-fidelity log-based replay. Experimental results demonstrate that Retriever incurs low runtime overhead in real-world robotic tasks while effectively ensuring behavioral reproducibility and reusability.

Existing generative world models exhibit poor performance in backtracking simulations—a limitation often mistakenly attributed to model capacity but actually stemming from deficiencies in runtime state management. This work proposes a session-centric runtime architecture that explicitly distinguishes between recomputable and non-recomputable states, introducing the concept of the minimal non-recomputable state (PCS) and enabling its efficient snapshotting and restoration. By capturing observations, random number generator states, memory banks, and sliding KV contexts, and employing a relevance-based rather than recency-based memory eviction policy, the system achieves state recovery in just 0.012 milliseconds—orders of magnitude faster than the 1.85 seconds required per generation step. The approach supports up to 1,024 concurrent sessions while ensuring exact backtracking fidelity and significantly enhancing scalability.

This work addresses the lack of effective governance and lifecycle management mechanisms for code artifacts generated by agents in multi-agent systems. It proposes HarnessMutation, a framework that models runtime evolution as a bounded and observable process over persistent operational memory. By integrating verifiable, traceable, evaluable, and rollback-capable mechanisms, HarnessMutation enables continuous self-adaptation within the cognitive loop. The approach combines an executable operational cognitive model with a governance-oriented orchestration system to support lifecycle-aware runtime evolution. This study establishes both a theoretical foundation and a practical pathway for adaptive agent infrastructures that balance flexibility with controllability.

Traditional programming models lack structured mechanisms for governing side effects, making it difficult to reliably oversee the behavior of autonomous systems. This work proposes an intent-driven computing model in which programs generate only declarative “intents” describing proposed actions. These intents are then vetted by a managed runtime against a decidable policy language and, upon approval, recorded in a tamper-evident ledger before execution. By shifting governance from the undecidable domain of program semantics to the decidable domain of intent data, the approach enables event sourcing, intent replay, structured auditing, and high human interpretability. An implementation atop the BEAM virtual machine integrates Rocq formal verification—encompassing 454 theorems—and over 70,000 property-based tests, achieving full verification of the specification’s null hypothesis lemma and strong alignment between implementation and formal specification, thereby establishing the first programming model for autonomous systems with built-in governance capabilities.