SKILL.state: Scalable Long-Horizon Agent Skills

# SKILL.state: Scalable Long-Horizon Agent Skills
Source: [https://arxiv.org/html/2608.26263](https://arxiv.org/html/2608.26263)
Priyanka Tiwari, Jonghyun ChungAffiliation:Google LLCAffiliation:Purdue University

###### Abstract

Large Language Models \(LLMs\) increasingly act as autonomous agents executing complex, long\-running procedural skills\. Existing agent runtimes maintain execution by continually appending observations, actions, and intermediate reasoning traces to an ever\-growing conversation history, causing latency degradation and context\-poisoning failures over long horizons\. We presentSKILL\.state, a runtime architecture that replaces append\-only conversational history with an explicit, mutable execution state\. At each execution step, the model receives only the immutable skill specification, the current structured execution state, and the latest observation\. Intermediate reasoning is discarded immediately after producing a validated state update, preventing prompt growth with execution history\. Across diverse datasets, models, and execution environments, SKILL\.state improves task accuracy while substantially reducing cumulative token consumption\. Our results demonstrate that explicit execution state is an effective and architecture\-agnostic abstraction for scalable long\-horizon agent skills\.

## 1Introduction

Large Language Models \(LLMs\) have rapidly evolved from passive language interfaces into autonomous systems capable of iterative reasoning, tool use, and interaction with external environments\([Yao et al\., 2022](https://arxiv.org/html/2608.26263#bib.bib1);[Schick et al\., 2023](https://arxiv.org/html/2608.26263#bib.bib3);[Qin et al\., 2024](https://arxiv.org/html/2608.26263#bib.bib4);[Wu et al\., 2023](https://arxiv.org/html/2608.26263#bib.bib5)\)\. Recent work further demonstrates that these capabilities can be encapsulated as reusable procedural skills, enabling agents to perform software engineering, workflow automation, web interaction, and scientific discovery through modular compositions of specialized behaviors\([Badhe et al\., 2026](https://arxiv.org/html/2608.26263#bib.bib13)\)\. As agents increasingly execute long\-running procedures, execution itself becomes a systems problem rather than purely a reasoning problem\.

Modern agent runtimes almost universally adopt a conversational execution model\. At every execution step, the language model receives the original skill specification together with an ever\-growing transcript of previous reasoning, actions, observations, and tool outputs\([Yao et al\., 2022](https://arxiv.org/html/2608.26263#bib.bib1);[Mialon et al\., 2023](https://arxiv.org/html/2608.26263#bib.bib6)\)\. Although memory systems alleviate context growth through summarization or retrieval\([Packer et al\., 2023](https://arxiv.org/html/2608.26263#bib.bib2);[Wang et al\., 2023](https://arxiv.org/html/2608.26263#bib.bib9);[Zhong et al\., 2023](https://arxiv.org/html/2608.26263#bib.bib8)\), they preserve the same execution semantics: future decisions are conditioned on textual reconstructions of past execution rather than an explicit representation of the current execution state\.

This design introduces fundamental limitations for long\-horizon procedural skills\. Prompt size grows with execution length, increasing token consumption and inference cost\([Liu et al\., 2024](https://arxiv.org/html/2608.26263#bib.bib12);[Xiao et al\., 2024a](https://arxiv.org/html/2608.26263#bib.bib15)\)\. Historical observations and obsolete reasoning remain embedded in the context long after they cease to be relevant, requiring the model to continually distinguish current facts from historical artifacts\. Consequently, execution correctness increasingly depends on reconstructing state from accumulated textual history\.

In this paper, we introduceSKILL\.state, a runtime architecture that reformulates procedural skill execution as explicit state transitions rather than conversational history accumulation\. Figure[1](https://arxiv.org/html/2608.26263#S3.F1)provides an overview of the proposed runtime\. At execution steptt, the language model receives only three inputs:

At=\(P,Σt,Ot\),A\_\{t\}=\(P,\\Sigma\_\{t\},O\_\{t\}\),\(1\)wherePPdenotes the immutable procedural specification,Σt\\Sigma\_\{t\}is the structured execution state, andOtO\_\{t\}is the latest environment observation\. After producing a validated state update, the intermediate reasoning trace is discarded while only the updated execution state is retained\. Consequently, execution depends strictly on the current world state instead of replaying historical trajectories\.

To evaluate this hypothesis, we evaluate SKILL\.state across both synthetic and real\-world benchmarks: SkillExecBench, a controlled benchmark designed for long\-horizon procedural skill execution under scaling, noise, and state recovery; InterCode CTF\([Yang et al\., 2023](https://arxiv.org/html/2608.26263#bib.bib26)\), featuring interactive Linux terminal exploitation; and Sierraτ\\tau\-Bench\([Yao et al\., 2024](https://arxiv.org/html/2608.26263#bib.bib27)\), evaluating multi\-turn customer\-service workflows over complex database APIs\.

Experimental results demonstrate that explicit execution state substantially improves the scalability of long\-horizon procedural skills by maintaining bounded prompt sizes while cutting token consumption and outperforming history\-based and compression\-based baselines across multiple model families\.

Our contributions are summarized as follows:

- •We proposeSKILL\.state, a runtime architecture that executes procedural skills through explicit structured execution state where intermediate reasoning is discarded after each step, proving a strictly bounded𝒪⁡\(1\)\\mathcal\{O\}\(1\)prompt footprint and𝒪⁡\(T\)\\mathcal\{O\}\(T\)cumulative token complexity\.
- •We present SkillExecBench, alongside evaluations on public benchmarks \(InterCode CTF and Sierraτ\\tau\-Bench\), for evaluating long\-horizon procedural skill execution in sequential, stateful environments\.
- •Across multiple execution horizons and runtime baselines, we demonstrate that state\-centric execution maintains competitive task performance while substantially reducing prompt growth and cumulative token consumption across both proprietary and open\-weight models\.

## 2Related Work

This section positions SKILL\.state against prior work on procedural skills, memory architectures for long\-horizon agents, dialogue state tracking, and long\-context reasoning; in each case the contrast is that prior work manages conversational history where we remove it\.

### 2\.1Procedural Skills for LLM Agents

Existing research on reusable procedural skills primarily addresses skill discovery, representation, composition, and security threat modeling\([Badhe et al\., 2026](https://arxiv.org/html/2608.26263#bib.bib13);[Badhe and Tiwari, 2026](https://arxiv.org/html/2608.26263#bib.bib14)\)\. Our work instead focuses on the largely unexplored mechanics of skill execution once a skill has been selected\.

### 2\.2Memory Architectures for Long\-Horizon Agents

Long\-horizon agent architectures typically preserve conversational semantics through episodic retrieval\([Park et al\., 2023](https://arxiv.org/html/2608.26263#bib.bib7)\)or persistent storage\([Chhikara et al\., 2025](https://arxiv.org/html/2608.26263#bib.bib16);[Zhong et al\., 2024](https://arxiv.org/html/2608.26263#bib.bib17)\)\. These methods leave execution state implicitly distributed across accumulated logs\. SKILL\.state instead isolates execution into an explicit, mutable runtime state, eliminating the need to repeatedly reconstruct world models from textual history\. Frameworks like LangGraph use auxiliary structured state to orchestrate workflows across agent nodes\. However, these systems still rely on conversational transcripts as the primary reasoning substrate\. SKILL\.state replaces this substrate by discarding intermediate reasoning traces immediately after producing validated state transitions\.

### 2\.3Dialogue State Tracking

Dialogue State Tracking \(DST\) maintains user slot values across conversational turns in task\-oriented dialogue\([Williams et al\., 2013](https://arxiv.org/html/2608.26263#bib.bib18);[Henderson et al\., 2014](https://arxiv.org/html/2608.26263#bib.bib19);[Rastogi et al\., 2020](https://arxiv.org/html/2608.26263#bib.bib20);[Wu et al\., 2019](https://arxiv.org/html/2608.26263#bib.bib21);[Heck et al\., 2020](https://arxiv.org/html/2608.26263#bib.bib22);[Hosseini\-Asl et al\., 2020](https://arxiv.org/html/2608.26263#bib.bib23)\)\. While both DST and SKILL\.state maintain structured representations, they differ fundamentally in execution mechanics: DST tracks auxiliary state alongside full conversational transcripts in quasi\-static dialogues, whereas SKILL\.state treats the structured state as a sufficient statistic, discarding conversational history to execute autonomous skills in dynamic environments with bounded prompt footprints\.

### 2\.4Context Management and Long\-Context Reasoning

Language models exhibit degraded retrieval over long contexts\([Liu et al\., 2024](https://arxiv.org/html/2608.26263#bib.bib12);[Zhang et al\., 2024](https://arxiv.org/html/2608.26263#bib.bib11)\), motivating streaming attention\([Xiao et al\., 2024b](https://arxiv.org/html/2608.26263#bib.bib10)\)and prompt compression techniques\([Jiang et al\., 2023](https://arxiv.org/html/2608.26263#bib.bib24);[Li et al\., 2023](https://arxiv.org/html/2608.26263#bib.bib25)\)\. Rather than attempting to process or compress extended conversational histories, SKILL\.state prevents history accumulation entirely by maintaining the canonical execution state required for the next computation\.

## 3SKILL\.state

Current LLM agent runtimes execute procedural skills by repeatedly appending reasoning traces, actions, observations, and tool outputs to a growing conversational history\. Consequently, the execution state is represented implicitly within natural language and must be reconstructed by the language model at every interaction\. As execution horizons increase, both prompt size and the volume of obsolete information grow monotonically, making execution increasingly dependent on interpreting historical text rather than maintaining the current world state\.

SKILL\.state reformulates procedural skill execution as an explicit state transition process\. Instead of representing execution as an append\-only conversation, every execution step is defined by:

At=\(P,Σt,Ot\),A\_\{t\}=\(P,\\Sigma\_\{t\},O\_\{t\}\),\(2\)wherePPis the immutable procedural specification,Σt\\Sigma\_\{t\}is the structured execution state at steptt, andOtO\_\{t\}is the latest observation received from the environment\. The language model never receives previous observations, previous actions, or previous reasoning traces\.

Figure[1](https://arxiv.org/html/2608.26263#S3.F1)illustrates the execution cycle\. At each step, the runtime constructs a prompt from\(P,Σt,Ot\)\(P,\\Sigma\_\{t\},O\_\{t\}\), invokes the language model, deterministically validates the proposed state transition, updates the execution state, executes the selected action, and repeats the process using the updated state\.

Figure 1:Overview of the SKILL\.state architecture\.### 3\.1Execution State and Schema Authoring

Unlike conversational runtimes, SKILL\.state treats execution state as a first\-class runtime abstraction\. The state contains only information required for future execution and is represented using a structured schema defined for the domain\. Schemas are authored once per domain rather than per task; for example, across all 100 diverse challenge instances in the InterCode CTF benchmark, the agent reuses a single static 5\-field schema \(discovered\_flags,tested\_hypotheses,active\_files,working\_dir,cmd\_summary\)\.

### 3\.2Reasoning and State Transitions

Reasoning is used strictly as an intermediate computation for producing state transitions and selecting the next action\. Given the current execution context\(P,Σt,Ot\)\(P,\\Sigma\_\{t\},O\_\{t\}\), the language model generates:

\(Rt,Δ​Σt,at\),\(R\_\{t\},\\Delta\\Sigma\_\{t\},a\_\{t\}\),\(3\)whereRtR\_\{t\}denotes the multi\-step Chain\-of\-Thought reasoning trace,Δ​Σt\\Delta\\Sigma\_\{t\}is a structured state update \(a JSON dictionary of key mutations and deletions\), andata\_\{t\}is the action to execute\.

Crucially, within\-step multi\-step reasoning is fully intact during generation to support complex deductive planning\. However, once the state transition has been validated and applied, the reasoning traceRtR\_\{t\}is discarded permanently and never appears in subsequent prompts\. The execution state is updated according to:

Σt\+1=Σt⊕Δ​Σt,\\Sigma\_\{t\+1\}=\\Sigma\_\{t\}\\oplus\\Delta\\Sigma\_\{t\},\(4\)where⊕\\oplusdenotes the runtime’s dictionary merge operator with null\-deletion semantics\. This model projects transient reasoning into persistent structured state, allowing only information required for future execution to survive across interactions\.

Algorithm 1SKILL\.state Runtime1:Procedural specification

PP, initial state

Σ0\\Sigma\_\{0\}
2:for

t=0,…,Tt=0,\\ldots,Tdo

3:Receive latest observation

OtO\_\{t\}
4:Construct prompt

\(P,Σt,Ot\)\(P,\\Sigma\_\{t\},O\_\{t\}\)
5:Generate

\(Rt,Δ​Σt,at\)\(R\_\{t\},\\Delta\\Sigma\_\{t\},a\_\{t\}\)using the LLM

6:Validate

Δ​Σt\\Delta\\Sigma\_\{t\}
7:

Σt\+1←Σt⊕Δ​Σt\\Sigma\_\{t\+1\}\\leftarrow\\Sigma\_\{t\}\\oplus\\Delta\\Sigma\_\{t\}
8:Execute

ata\_\{t\}
9:endfor

Algorithm[1](https://arxiv.org/html/2608.26263#alg1)summarizes the execution process\.

### 3\.3Complexity Analysis

LetTTdenote the execution horizon\. For conversational runtimes, prompt length grows with the accumulated interaction history,\|Ct\|=𝒪⁡\(t\)\|C\_\{t\}\|=\\mathcal\{O\}\(t\), leading to cumulative token complexity:

∑t=1T\|Ct\|=𝒪⁡\(T2\)\.\\sum\_\{t=1\}^\{T\}\|C\_\{t\}\|=\\mathcal\{O\}\(T^\{2\}\)\.\(5\)
In contrast, SKILL\.state maintains only the procedural specification, structured execution state, and latest observation:

\|Pt\|=𝒪⁡\(\|P\|\+\|Σ\|\+\|O\|\),\|P\_\{t\}\|=\\mathcal\{O\}\(\|P\|\+\|\\Sigma\|\+\|O\|\),\(6\)which is asymptotically bounded and independent of the number of previously executed turnstt\. Consequently, cumulative prompt complexity grows strictly linearly with the execution horizon:

∑t=1T\|Pt\|=𝒪⁡\(T\)\.\\sum\_\{t=1\}^\{T\}\|P\_\{t\}\|=\\mathcal\{O\}\(T\)\.\(7\)
The resulting runtime shifts execution from reconstructing history toward maintaining an explicit, validated representation of the current execution state\.

## 4Evaluation Benchmarks

### 4\.1SkillExecBench \(Controlled Diagnostic Testbed\)

SkillExecBench isolates execution mechanics from open\-ended heuristic search by providing sequential procedural tasks with deterministic ground\-truth world transitions:

- •Environment 1 \(Warehouse Management\):A discrete physical inventory domain tracking 500 independent shelves\. Actions includeStore,Ship,Move, andWait\. This environment tests the model’s ability to maintain independent, non\-overlapping state variables over extended horizons where early observations leave the context window\.
- •Environment 2 \(Software Repository\):A deeply nested, relational graph of Git branches, commits, Pull Requests, and CI test statuses\. Actions includeCherryPick,Merge,RunTests,CreateRelease, andRollback\. Features dense dependencies where a single action \(e\.g\., merging a PR\) fundamentally alters the state of the target branch and dependent PRs, testing complex structural reasoning over an entangled graph\.

### 4\.2Public Interactive Benchmarks

To evaluate SKILL\.state on real\-world, non\-deterministic tasks with complex search, generation, and tool use, we evaluate on two public benchmarks:

- •InterCode CTF\([Yang et al\., 2023](https://arxiv.org/html/2608.26263#bib.bib26)\):A suite of 100 Linux bash Capture\-The\-Flag challenges spanning reverse engineering, forensics, cryptography, and binary exploitation\. Agents execute bash commands in Docker containers and iteratively test hypotheses to discover hidden flags\.
- •Sierraτ\\tau\-Bench\([Yao et al\., 2024](https://arxiv.org/html/2608.26263#bib.bib27)\):A benchmark for tool\-agent\-user interaction in enterprise customer service \(Retail and Airline domains\)\. Agents interact with simulated users, query relational SQLite databases via tool calls, and execute transactional actions \(e\.g\., flight rebooking, refunds\) under business policy constraints\.

### 4\.3Evaluation Metrics

We evaluate runtimes across three dimensions:

- •Task Accuracy / Success Rate:In SkillExecBench, accuracy is measured continuously as the ratio of valid, correct actions matching the ground\-truth deterministic simulation \(Score=Successful ActionsTotal Actionable Events\\text\{Score\}=\\frac\{\\text\{Successful Actions\}\}\{\\text\{Total Actionable Events\}\}\)\. In InterCode CTF, success is binary pass@1 \(exact match on the binary\-verified flag\)\. Inτ\\tau\-Bench, success is scored by the official programmatic evaluator, which verifies that the final database state satisfies user intent without policy violations\.
- •Average Prompt Size:The mean token footprint per LLM invocation\.
- •Total Token Cost:The cumulative token burn across the entire execution horizon\.

Table 1:Warehouse Management Long\-Horizon Scaling using Gemini\-3\-Flash\. Baseline runtimes suffer𝒪⁡\(T2\)\\mathcal\{O\}\(T^\{2\}\)context accumulation, whereas SKILL\.state maintains a bounded𝒪⁡\(1\)\\mathcal\{O\}\(1\)prompt footprint \(Mean±\\pmSD across 5 seeds\)\.

## 5Experiments and Results

### 5\.1Experimental Setup

We evaluate SKILL\.state against two families of baselines \(see Appendix[Appendix A\. Runtime Prompts](https://arxiv.org/html/2608.26263#Ax1)for exact prompt templates\):

Primary Runtime Paradigms:

1. 1\.Prompt \(ReAct\-style\):Appends every observation, intermediate reasoning trace, and action to a continually growing transcript\([Yao et al\., 2022](https://arxiv.org/html/2608.26263#bib.bib1)\)\.
2. 2\.Memory \(Summarization\-style\):Maintains a rolling 3\-step conversational window alongside a periodically updated natural language summary of past interactions\([Packer et al\., 2023](https://arxiv.org/html/2608.26263#bib.bib2)\)\.
3. 3\.Stateful \(LangGraph\-style\):Injects a structured state block into the context window alongside the full rolling conversational transcript\.

Budget\-Matched and Compression Controls:

1. 1\.Truncated \(Sliding Window\):Retains only the most recent interaction turns that fit within a fixed token budget\.
2. 2\.Summary\-capped:Strictly enforces a hard token ceiling on the natural language summary\.
3. 3\.ReAct \+ LLMLingua\([Jiang et al\., 2023](https://arxiv.org/html/2608.26263#bib.bib24)\):Uses budget\-aware small\-model perplexity compression to prune tokens from the full history down to the target budget\.

Underlying Models:Evaluations are conducted across proprietary and open\-weight models: Gemini\-3\-Flash, Gemma\-4\-31B\-it, and Qwen\-3\-8B\-it\. Decoding is controlled at temperature0\.00\.0and top\-pp1\.01\.0across all runs to ensure deterministic reproducibility\.

Statistical Significance:All synthetic experiments are evaluated across 5 distinct procedural generator seeds\. Results are reported as mean±\\pmsample standard deviation\. Differences between SKILL\.state and baselines at extended horizons \(T≥50T\\geq 50\) are statistically significant \(pairedtt\-test,p<0\.01p<0\.01\)\.

### 5\.2Experiment 1: Long\-Horizon Execution Scaling

We evaluate runtime accuracy and context expansion across execution horizons scaling fromT=10T=10toT=200T=200steps\.

Results:As shown in Table[1](https://arxiv.org/html/2608.26263#S4.T1), SKILL\.state matches or exceeds baseline accuracy across all horizons while maintaining a flat prompt size \(∼\\sim1,736–1,905 tokens\)\. In contrast, history\-appending baselines suffer quadratic token accumulation𝒪⁡\(T2\)\\mathcal\{O\}\(T^\{2\}\)\. AtT=100T=100, the Stateful baseline consumes 1,062,387 tokens, whereas SKILL\.state consumes only 65,408 tokens \(a16\.2×16\.2\\timestoken reduction\)\. AtT=200T=200, SKILL\.state maintains 0\.94 accuracy consuming 122k tokens, while the Memory baseline inflates to 6\.1M tokens\. Additional scaling results for the Software Repository and open\-weight models are detailed in Appendix[Appendix D\. Additional Results](https://arxiv.org/html/2608.26263#Ax4)\.

Table 2:Warehouse Noise Robustness \(T=50T=50, Gemini\-3\-Flash\)\.
### 5\.3Experiment 2: Context Corruption \(Noise Robustness\)

Real\-world execution environments emit dense background telemetry\. We fix the horizon atT=50T=50and inject distractor events \(system telemetry, irrelevant git branch activities, and rule overrides\) at rates of 5, 20, and 50 events per turn \(see Appendix[Appendix C\. Noise Construction \(Experiment 2\)](https://arxiv.org/html/2608.26263#Ax3)for calibration details\)\.

Results:As shown in Table[2](https://arxiv.org/html/2608.26263#S5.T2), the standardPromptruntime degrades sharply from 0\.68 at low noise down to 0\.53 at high noise\. In contrast, SKILL\.state maintains robust task completion \(≥0\.97\\geq 0\.97\) across all noise levels because distractors are filtered out during state patch generation and never enter subsequent prompts\.

Table 3:Warehouse State Recovery \(Gemini\-3\-Flash\)\.ScenarioRuntimeSuccessRecovery StepsA: Secret AuditPrompt / Memory / StatefulYes5–8SKILL\.stateYes0B: Secret BarcodePrompt / Memory / StatefulYes6–8SKILL\.stateYes0C: Secret MovePrompt / Memory / StatefulYes5–8SKILL\.stateYes0D: Canceled OrderAll RuntimesNoN/A

### 5\.4Experiment 3: State Recovery

We test runtime resilience to silent external environment drift where the true world state is modified outside the agent’s action loop \(e\.g\., an external actor moves an inventory item\)\.

Results:As shown in Table[3](https://arxiv.org/html/2608.26263#S5.T3), history\-based baselines hallucinate for 5 to 8 consecutive turns because obsolete facts in their prompt history overpower contradictory new observations\. In sharp contrast, SKILL\.state requires zero recovery steps: because its decisions depend on the current structured state, the state is updated immediately upon receiving the corrective alert\.

Table 4:Evaluation on Public Interactive Benchmarks using Gemini\-3\-Flash\. SKILL\.state achieves the highest task success rates while significantly reducing prompt sizes and cumulative token consumption\.
### 5\.5Experiment 4: Public Interactive Benchmarks

To test generalizability on open\-ended tasks with complex search, generation, and tool use, we evaluate SKILL\.state on InterCode CTF and Sierraτ\\tau\-Bench\.

Results:As shown in Table[4](https://arxiv.org/html/2608.26263#S5.T4), SKILL\.state achieves the highest task completion rates across all three benchmarks while substantially cutting cumulative token consumption\. In InterCode CTF, maintaining explicit hypotheses and discovered flags inΣt\\Sigma\_\{t\}prevents the model from repeating failed commands, increasing pass@1 to 54\.2% \(\+7\.8 points over the strongest baseline and \+12\.4 points over Stateful\) while cutting total tokens by 60\.4% vs\. ReAct and 65\.9% vs\. Stateful\. Inτ\\tau\-Bench Retail, SKILL\.state leads with 58\.3% pass rate at the lowest total token cost\. Inτ\\tau\-Bench Airline, where complex database responses cause baseline prompts to peak above 11,000 tokens/step, SKILL\.state maintains a flat footprint of∼\\sim2,800 tokens/step and achieves a 32\.4% pass rate, saving 40\.5% tokens vs\. ReAct and 45\.4% vs\. Stateful\.

Table 5:Budget\-Matched Controls on Warehouse \(T=100T=100, Gemini\-3\-Flash, Budget∼\\sim1,800 tokens\)\.
### 5\.6Experiment 5: Budget\-Matched Controls and Statistical Compression

To determine whether SKILL\.state’s performance gains stem merely from shorter prompts or from structured state representation, we evaluate budget\-matched baselines on Warehouse \(T=100T=100, Gemini\-3\-Flash\) pinned to the token budget of SKILL\.state \(∼\\sim1,800 tokens\)\.

Results:As shown in Table[5](https://arxiv.org/html/2608.26263#S5.T5), all budget\-matched compression baselines suffer catastrophic failure\. Sliding\-window truncation drops to 0\.18 because critical early inventory allocations are evicted\. LLMLingua drops to 0\.22 because statistical entropy filtering removes seemingly redundant slot identifiers that are semantically vital\. In contrast, SKILL\.state achieves 0\.94 score, demonstrating that structured state maintenance preserves exact relational dependencies that statistical compressors destroy\.

### 5\.7Error Taxonomy for Open\-Weight Models

On open\-weight models \(Gemma\-4\-31B atT=100T=100, score 0\.42\), we analyze failure logs and categorize errors into three distinct modes:

1. 1\.Premature State Overwrite / Deletion \(68%\):The model accidentally omits existing keys during state update rather than merging in\-place\.
2. 2\.Schema Comprehension / Type Coercion \(20%\):Inconsistencies between expected nested lists and dictionaries\.
3. 3\.JSON Syntax / Formatting Slips \(12%\):Malformed JSON delimiters or trailing commas\.

This error distribution shows that small\-model degradation stems from structured output adherence rather than reasoning capacity, motivating constrained decoding in future runtime iterations\.

## 6Conclusion

We presentedSKILL\.state, a runtime architecture that replaces append\-only conversational history with explicit, structured execution state\. By discarding intermediate reasoning traces after each validated transition, SKILL\.state maintains a bounded𝒪⁡\(1\)\\mathcal\{O\}\(1\)prompt footprint and scales linearly𝒪⁡\(T\)\\mathcal\{O\}\(T\)in cumulative tokens\. Across controlled diagnostic tasks and public interactive benchmarks, explicit execution state consistently improves task accuracy while substantially reducing prompt growth and token consumption\.

## 7Limitations

SKILL\.state assumes that the execution state can be made a*sufficient statistic*for future execution: that everything in the past bearing on future actions can be projected into the structured state as soon as it becomes known\. Where this holds, discarding intermediate reasoning and conversational history is lossless\. However, this assumption fails in three distinct settings: \(1\) when no fixed schema is known in advance and the relevant state structure must be discovered dynamically during execution; \(2\) when a correct state update depends on an earlier observation whose relevance was not recognized when first observed, and was therefore never committed to state; and \(3\) when the task objective is defined over the historical trajectory itself \(e\.g\., auditing, debugging provenance, or explaining past actions\), where interaction history is the target output rather than operational overhead\.

Our current implementation focuses on single\-agent procedural execution\. While the explicit state abstraction extends naturally to multi\-agent systems—where a shared execution state acts as the central coordination substrate instead of exchanging quadratic conversational transcripts—multi\-agent environments introduce concurrent writes, requiring deterministic conflict\-resolution semantics in the merge operator⊕\\oplusthat our single\-agent setting does not exercise\.

Finally, SKILL\.state relies on the language model to propose valid structured state patches\. Because schema ownership and validation reside in the deterministic runtime rather than the model, malformed outputs cannot corrupt persistent stateΣt\\Sigma\_\{t\}; an invalid patch triggers a rollback\-retry cycle\. For smaller open\-weight models, integrating grammar\-constrained decoding can eliminate syntactic formatting errors, allowing the model to focus entirely on semantic state transitions\.

## References

- Badheet al\.\(2026\)S\. Badhe, D\. Shah, P\. Tiwari, and N\. KathrotiaA systematic survey of agent skills: lifecycle, taxonomy, and security\.Taxonomy, and Security \(July 31, 2026\)\.Cited by:[§1](https://arxiv.org/html/2608.26263#S1.p1.1),[§2\.1](https://arxiv.org/html/2608.26263#S2.SS1.p1.1)\.
- Badhe and Tiwari \(2026\)S\. Badhe and P\. TiwariAgent skill security: threat models, attacks, defenses, and evaluation\.External Links:2607\.13987,[Link](https://arxiv.org/abs/2607.13987)Cited by:[§2\.1](https://arxiv.org/html/2608.26263#S2.SS1.p1.1)\.
- Chhikaraet al\.\(2025\)P\. Chhikara, D\. Khant, S\. Aryan, T\. Singh, and D\. YadavMem0: building production\-ready ai agents with scalable long\-term memory\.arXiv preprint arXiv:2504\.19413\.Cited by:[§2\.2](https://arxiv.org/html/2608.26263#S2.SS2.p1.1)\.
- Hecket al\.\(2020\)M\. Heck, C\. van Niekerk, N\. Lubis, C\. Geishauser, H\. Lin, M\. Moresi, and M\. GašićTripPy: a triple copy strategy for value\-independent neural dialog state tracking\.InProceedings of the 21th Annual Meeting of the Special Interest Group on Discourse and Dialogue,pp\. 35–44\.Cited by:[§2\.3](https://arxiv.org/html/2608.26263#S2.SS3.p1.1)\.
- Hendersonet al\.\(2014\)M\. Henderson, B\. Thomson, and J\. D\. WilliamsThe second dialog state tracking challenge\.InProceedings of the 15th Annual Meeting of the Special Interest Group on Discourse and Dialogue \(SIGDIAL\),pp\. 263–272\.Cited by:[§2\.3](https://arxiv.org/html/2608.26263#S2.SS3.p1.1)\.
- Hosseini\-Aslet al\.\(2020\)E\. Hosseini\-Asl, B\. McCann, C\. Wu, S\. Yavuz, and R\. SocherA simple language model for task\-oriented dialogue\.Advances in Neural Information Processing Systems33,pp\. 20179–20191\.Cited by:[§2\.3](https://arxiv.org/html/2608.26263#S2.SS3.p1.1)\.
- Jianget al\.\(2023\)H\. Jiang, Q\. Wu, C\. Lin, Y\. Yang, and L\. QiuLLMLingua: compressing prompts for accelerated inference of large language models\.InProceedings of the 2023 Conference on Empirical Methods in Natural Language Processing \(EMNLP\),pp\. 13358–13376\.Cited by:[§2\.4](https://arxiv.org/html/2608.26263#S2.SS4.p1.1),[item 3](https://arxiv.org/html/2608.26263#S5.I2.i3.p1.1.1)\.
- Liet al\.\(2023\)Y\. Li, B\. Dong, F\. Zhang, D\. Wang, Y\. Xu, X\. Chen, and X\. RenCompressing context to enhance inference efficiency of large language models\.InProceedings of the 2023 Conference on Empirical Methods in Natural Language Processing \(EMNLP\),pp\. 6342–6353\.Cited by:[§2\.4](https://arxiv.org/html/2608.26263#S2.SS4.p1.1)\.
- Liuet al\.\(2024\)N\. F\. Liu, K\. Lin, J\. Hewitt, A\. Paranjape, M\. Bevilacqua, F\. Petroni, and P\. LiangLost in the middle: how language models use long contexts\.Transactions of the Association for Computational Linguistics12,pp\. 157–173\.External Links:[Link](https://aclanthology.org/2024.tacl-1.9/),[Document](https://dx.doi.org/10.1162/tacl%5Fa%5F00638)Cited by:[§1](https://arxiv.org/html/2608.26263#S1.p3.1),[§2\.4](https://arxiv.org/html/2608.26263#S2.SS4.p1.1)\.
- Mialonet al\.\(2023\)G\. Mialon, R\. Dessi, M\. Lomeli, C\. Nalmpantis, R\. Pasunuru, R\. Raileanu, B\. Roziere, T\. Schick, J\. Dwivedi\-Yu, A\. Celikyilmaz, E\. Grave, Y\. LeCun, and T\. ScialomAugmented language models: a survey\.Transactions on Machine Learning Research\.Note:Survey CertificationExternal Links:ISSN 2835\-8856,[Link](https://openreview.net/forum?id=jh7wH2AzKK)Cited by:[§1](https://arxiv.org/html/2608.26263#S1.p2.1)\.
- Packeret al\.\(2023\)C\. Packer, V\. Fang, S\. Patil, K\. Lin, S\. Wooders, and J\. GonzalezMemGPT: towards llms as operating systems\.\.Cited by:[§1](https://arxiv.org/html/2608.26263#S1.p2.1),[item 2](https://arxiv.org/html/2608.26263#S5.I1.i2.p1.1)\.
- Parket al\.\(2023\)J\. S\. Park, J\. C\. O’Brien, C\. J\. Cai, M\. R\. Morris, P\. Liang, and M\. S\. BernsteinGenerative agents: interactive simulacra of human behavior\.InProceedings of the 36th Annual ACM Symposium on User Interface Software and Technology \(UIST\),Cited by:[§2\.2](https://arxiv.org/html/2608.26263#S2.SS2.p1.1)\.
- Qinet al\.\(2024\)Y\. Qin, S\. Liang, Y\. Ye, K\. Zhu, L\. Yan, Y\. Lu, Y\. Lin, X\. Cong, X\. Tang, B\. Qian,et al\.ToolLLM: facilitating large language models to master 16000\+ real\-world apis\.InInternational Conference on Learning Representations \(ICLR\),Cited by:[§1](https://arxiv.org/html/2608.26263#S1.p1.1)\.
- Rastogiet al\.\(2020\)A\. Rastogi, X\. Zang, S\. Sunkara, R\. Gupta, and P\. KhaitanTowards scalable multi\-domain conversational agents: the schema\-guided dialogue dataset\.InProceedings of the AAAI Conference on Artificial Intelligence,Vol\.34,pp\. 8689–8696\.Cited by:[§2\.3](https://arxiv.org/html/2608.26263#S2.SS3.p1.1)\.
- Schicket al\.\(2023\)T\. Schick, J\. Dwivedi\-Yu, R\. Dessì, R\. Raileanu, M\. Lomeli, L\. Zettlemoyer, N\. Cancedda, and T\. ScialomToolformer: language models can teach themselves to use tools\.InAdvances in Neural Information Processing Systems \(NeurIPS\),Cited by:[§1](https://arxiv.org/html/2608.26263#S1.p1.1)\.
- Wanget al\.\(2023\)W\. Wang, L\. Dong, H\. Cheng, X\. Liu, X\. Yan, J\. Gao, and F\. WeiAugmenting language models with long\-term memory\.Advances in Neural Information Processing Systems \(NeurIPS\)\.Cited by:[§1](https://arxiv.org/html/2608.26263#S1.p2.1)\.
- Williamset al\.\(2013\)J\. Williams, A\. Raux, D\. Ramachandran, and A\. BlackThe dialog state tracking challenge\.InProceedings of the SIGDIAL 2013 Conference,pp\. 404–413\.Cited by:[§2\.3](https://arxiv.org/html/2608.26263#S2.SS3.p1.1)\.
- Wuet al\.\(2019\)C\. Wu, A\. Madotto, E\. Hosseini\-Asl, C\. Xiong, R\. Socher, and P\. FungTransferable multi\-domain state generator for task\-oriented dialogue systems\.InProceedings of the 57th Annual Meeting of the Association for Computational Linguistics,pp\. 808–819\.Cited by:[§2\.3](https://arxiv.org/html/2608.26263#S2.SS3.p1.1)\.
- Wuet al\.\(2023\)Q\. Wu, G\. Bansal, J\. Zhang, Y\. Wu, B\. Li, E\. Zhu, L\. Jiang, X\. Zhang, S\. Zhang, J\. Liu,et al\.AutoGen: enabling next\-gen llm applications via multi\-agent conversation\.arXiv preprint arXiv:2308\.08155\.Cited by:[§1](https://arxiv.org/html/2608.26263#S1.p1.1)\.
- Xiaoet al\.\(2024a\)G\. Xiao, Y\. Tian, B\. Chen, S\. Han, and M\. LewisEfficient streaming language models with attention sinks\.InInternational Conference on Learning Representations \(ICLR\),Cited by:[§1](https://arxiv.org/html/2608.26263#S1.p3.1)\.
- Xiaoet al\.\(2024b\)G\. Xiao, Y\. Tian, B\. Chen, S\. Han, and M\. LewisEfficient streaming language models with attention sinks\.InInternational Conference on Learning Representations,Vol\.2024,pp\. 21875–21895\.Cited by:[§2\.4](https://arxiv.org/html/2608.26263#S2.SS4.p1.1)\.
- Yanget al\.\(2023\)J\. Yang, A\. Prabhakar, K\. Narasimhan, and S\. YaoInterCode: standardizing and benchmarking interactive coding with execution feedback\.InAdvances in Neural Information Processing Systems \(NeurIPS\),Cited by:[§1](https://arxiv.org/html/2608.26263#S1.p5.1),[1st item](https://arxiv.org/html/2608.26263#S4.I2.i1.p1.1.1)\.
- Yaoet al\.\(2024\)S\. Yao, N\. Shinn, J\. Zhao, Q\. Wu, and K\. Narasimhanτ\\tau\-Bench: a benchmark for tool\-agent\-user interaction in real\-world domains\.arXiv preprint arXiv:2406\.12045\.Cited by:[§1](https://arxiv.org/html/2608.26263#S1.p5.1),[2nd item](https://arxiv.org/html/2608.26263#S4.I2.i2.p1.1.1)\.
- Yaoet al\.\(2022\)S\. Yao, J\. Zhao, D\. Yu, N\. Du, I\. Shafran, K\. Narasimhan, and Y\. CaoReact: synergizing reasoning and acting in language models\.arXiv preprint arXiv:2210\.03629\.Cited by:[§1](https://arxiv.org/html/2608.26263#S1.p1.1),[§1](https://arxiv.org/html/2608.26263#S1.p2.1),[item 1](https://arxiv.org/html/2608.26263#S5.I1.i1.p1.1)\.
- Zhanget al\.\(2024\)X\. Zhang, Y\. Chen, S\. Hu, Z\. Xu, J\. Chen, M\. Hao, X\. Han, Z\. Thai, S\. Wang, Z\. Liu,et al\.Infinite bench: extending long context evaluation beyond 100k tokens\.InProceedings of the 62nd Annual Meeting of the Association for Computational Linguistics \(Volume 1: Long Papers\),pp\. 15262–15277\.Cited by:[§2\.4](https://arxiv.org/html/2608.26263#S2.SS4.p1.1)\.
- Zhonget al\.\(2023\)W\. Zhong, L\. Guo, Q\. Gao, H\. Y\. Wang, and Y\. LinMemoryBank: enhancing large language models with long\-term memory\.arXiv preprint arXiv:2305\.10250\.Cited by:[§1](https://arxiv.org/html/2608.26263#S1.p2.1)\.
- Zhonget al\.\(2024\)W\. Zhong, L\. Guo, Q\. Gao, H\. Ye, and Y\. WangMemorybank: enhancing large language models with long\-term memory\.InProceedings of the AAAI conference on artificial intelligence,Vol\.38,pp\. 19724–19731\.Cited by:[§2\.2](https://arxiv.org/html/2608.26263#S2.SS2.p1.1)\.

## Appendix A\. Runtime Prompts

This appendix provides the exact system prompts used by the four evaluated runtimes\. To ensure reproducibility, all prompts are presented exactly as they were dynamically constructed and formatted in the benchmark execution loop\.

### A\.1 Prompt Runtime \(ReAct\-style\)

Instructions:

\{skill\.instructions\}

History:

Observation:\{history\[0\]\.observation\}

Reasoning&Action:\{history\[0\]\.response\}

\[\.\.\.Appendsallpreviousobservationsandactions\.\.\.\]

LatestObservation:\{observation\}

Generateyournextreasoningandaction\(format’Action:<cmd\>’\):

### A\.2 Memory\-Augmented Runtime

Instructions:

\{skill\.instructions\}

SummarizedHistory:

\{summary\_string\_of\_past\_steps\}

RecentHistory:

Observation:\{recent\_observations\[0\]\}

Response:\{recent\_responses\[0\]\}

\[\.\.\.Appendsthe3mostrecentturns\.\.\.\]

LatestObservation:\{observation\}

Generateyournextreasoningandaction\(format’Action:<cmd\>’\):

### A\.3 Stateful Runtime \(LangGraph\-style\)

Instructions:

\{skill\.instructions\}

CurrentState:

\{json\.dumps\(state,indent=2\)\}

History:

Observation:\{history\[0\]\.observation\}

Response:\{history\[0\]\.response\}

\[\.\.\.Appendsallpreviousobservationsandactions\.\.\.\]

LatestObservation:\{observation\}

Updatethestateifnecessary,providereasoning,andoutput’Action:<cmd\>’\.

Toupdatestate,usetheformat:StateUpdate:\{"key":"value"\}

### A\.4 SKILL\.state Runtime

Instructions:

\{skill\.instructions\}

SkillExecutionState:

‘‘‘json

\{json\.dumps\(state,separators=\(’,’,’:’\)\)\}

LatestObservation:\{observation\}

Provideyourresponsewith:

1\.Step\-by\-stepreasoning\(willbediscardedafterexecution\)

2\.AJSONblockfencedwithjson\.\.\.containingbothyourStatePatchandyourAction\.TheJSONblockMUSThaveexactlythesetwokeys:\{"state\_patch":\{<dict:yourstateupdates,setkeystonulltodelete\>\},"action":"<string:theexactcommandyouwanttoexecute\>"\}

Note:Theskill\.instructionsplaceholder dynamically injects the task\-specific system prompt \(e\.g\., the agent’s persona, the available action space, and the environment rules\)\. This ensures that across all runtime evaluations, the agent receives the exact same baseline instructions, isolating context management as the only independent variable\.

## Appendix B\. SkillExecBench Implementation Details

To maintain focus on the core experimental findings in Section 5, we provide the full implementation details of the SkillExecBench environments, task generation logic, and episode trajectories in this appendix\.

### B\.1 Environment Design

#### Environment 1: Warehouse Management

- •State Representation:A discrete inventory mapping of 500 independent shelves \(e\.g\.,shelf\_0throughshelf\_499\), where each shelf holds exactly one item string identifier or isnull\.
- •Action Space: - –Store <item\_id\> <empty\_shelf\_id\> - –Ship <item\_id\> <shelf\_id\> - –Move <item\_id\> <old\_shelf\_id\> <new\_shelf\_id\> - –Wait
- •Observation Format:Textual alerts triggered by system events, including:Shipment arrived containing \[item\],Customer ordered \[item\], andMaintenance required on \[shelf\]\.
- •Transition Rules:If an agent callsStore, the environment validates the shelf is empty before placing the item\. IfShipis called, the item is destroyed\. Invalid actions \(e\.g\., storing an item on an occupied shelf\) return a local error observation and reject the state transition\.
- •Success Criterion:The ratio of successfully executed valid actions matching the ground\-truth deterministic simulation \(Score = Successful Actions / Total Actionable Events\)\.

#### Environment 2: Software Repository

- •State Representation:A simulated Git repository tracking branch histories, file contents, active Pull Requests \(PRs\), and Continuous Integration \(CI\) test statuses\.
- •Action Space:Commit\(branch, file\),CreatePR\(branch\),Merge\(pr\_id\),FixCI\(branch\),Wait\.
- •Observation Format:CI/CD webhook notifications \(e\.g\.,CI Pipeline Failed for PR \#3\), code review comments, and issue assignments\.
- •Transition Rules:Pushing a commit triggers a background CI evaluation transition\. Merging a PR successfully transitions the master branch state and deletes the feature branch\.
- •Success Criterion:The percentage of correctly resolved feature requests merged into master without breaking CI checks\.

### B\.2 Task Generation

Tasks are procedurally generated using a deterministic random number generator\. By seeding the generator, we guarantee that all evaluated baseline runtimes experience the exact same sequence of events, ensuring fair comparisons\. The horizon length dictates the number of sequential events the agent must handle\.

Algorithm 2Warehouse Task Generation Pseudo\-code1:

s​e​e​d←42seed\\leftarrow 42
2:

r​n​g←Random​\(s​e​e​d\)rng\\leftarrow\\text\{Random\}\(seed\)
3:

gt\_shelves←\{shelf\_0: Null, …, shelf\_499: Null\}gt\\\_shelves\\leftarrow\\\{\\text\{shelf\\\_0: Null, \.\.\., shelf\\\_499: Null\}\\\}
4:

e​v​e​n​t​s←\[\]events\\leftarrow\[\]
5:for

i=1i=1to

H​o​r​i​z​o​nHorizondo

6:

a​v​a​i​l​a​b​l​e←FindEmptyShelves​\(g​t​\_​s​h​e​l​v​e​s\)available\\leftarrow\\text\{FindEmptyShelves\}\(gt\\\_shelves\)
7:

o​c​c​u​p​i​e​d←FindOccupiedShelves​\(g​t​\_​s​h​e​l​v​e​s\)occupied\\leftarrow\\text\{FindOccupiedShelves\}\(gt\\\_shelves\)
8:

p​o​s​s​i​b​l​e​\_​e​v​e​n​t​s←\[Receive\]possible\\\_events\\leftarrow\[\\text\{Receive\}\]
9:if

o​c​c​u​p​i​e​d​is not emptyoccupied\\text\{ is not empty\}then

10:

p​o​s​s​i​b​l​e​\_​e​v​e​n​t​s​\.append​\(Order,Maintenance\)possible\\\_events\\text\{\.append\}\(\\text\{Order\},\\text\{Maintenance\}\)
11:endif

12:

e​v​e​n​t​\_​t​y​p​e←r​n​g​\.choice​\(p​o​s​s​i​b​l​e​\_​e​v​e​n​t​s\)event\\\_type\\leftarrow rng\\text\{\.choice\}\(possible\\\_events\)
13:

e​v​e​n​t​s​\.append​\(ConstructObservation​\(e​v​e​n​t​\_​t​y​p​e\)\)events\\text\{\.append\}\(\\text\{ConstructObservation\}\(event\\\_type\)\)
14:

UpdateGroundTruth​\(g​t​\_​s​h​e​l​v​e​s,e​v​e​n​t​\_​t​y​p​e\)\\text\{UpdateGroundTruth\}\(gt\\\_shelves,event\\\_type\)
15:endfor

16:return

e​v​e​n​t​sevents

### B\.3 Example Episode Trajectory

To illustrate the execution flow, below is a concrete, single\-turn trajectory for theSKILL\.stateruntime operating in the Warehouse environment\.

1\. Observation Received \(Environment→\\rightarrowLLM\)

LatestObservation:

Customerordereditem\_12\.

2\. LLM Processing \(LLM Internal\)

Reasoning:

Thecustomerordereditem\_12\.Ineedtoshipit\.

IwillcheckmySkillExecutionStatetolocateit\.

Lookingatthestateschema,item\_12islocatedonshelf\_42\.

ImustgenerateaShipactionandupdatemystatetoremoveitfromshelf\_42\.

3\. State Update and Action Generation \(LLM→\\rightarrowRuntime\)

\{

"state\_patch":\{

"inventory":\{

"shelf\_42":null

\}

\},

"action":"Shipitem\_12shelf\_42"

\}

4\. Next Observation \(Environment→\\rightarrowLLM\)

LatestObservation:

Success:Shippeditem\_12fromshelf\_42\.

## Appendix C\. Noise Construction \(Experiment 2\)

In Experiment 2, we evaluate the runtimes’ resilience to dense, irrelevant contextual noise\. Real\-world systems rarely provide clean, perfectly isolated observation spaces; agents must constantly filter out background telemetry, sensor logs, and system chatter to execute their instructions\.

To isolate the problem ofAttention Drag, the experiments in this paper exclusively focus onCondition 1: Irrelevant Context\.

### C\.1 Noise Properties

For Condition 1 evaluations across both environments, the injected noise strings are defined by three strict properties:

1. 1\.Randomly Generated:Values such as battery percentages, temperatures, server IDs, and CPU loads are sampled uniformly at random during each execution step\.
2. 2\.Strictly Irrelevant:The semantic meaning of the noise has absolutely no bearing on the agent’s primary task \(e\.g\., fulfilling warehouse orders or fixing CI pipelines\)\.
3. 3\.Non\-State\-Altering:The noise events never actually change the underlying ground\-truth world state\. They are purely observational distractors appended to the environment’s response payload under a\-\-\- BACKGROUND TELEMETRY \-\-\-header\.

### C\.2 Environment 1 \(Warehouse\) Distractors

To simulate a realistic noisy warehouse, the generator randomly selects from the following categories to inject irrelevant strings into the agent’s observation space:

#### 1\. Robot Telemetry Logs

Simulates continuous pinging from automated warehouse robots navigating the floor\.

Battery:85%,Temperature:45C,CPULoad:72%,

Speed:1\.2m/s,NavConfidence:95\.4%

#### 2\. Environmental Sensor Logs

Simulates passive HVAC and ambient sensor readings\.

\[Sensor\]Humidity:45%,Temp:22\.3C,Light:310lux,CO2:450ppm

#### 3\. Camera OCR / Vision Logs

Simulates background security camera or computer\-vision object detection events\.

\[CameraOCR\]Forkliftparked\.

\[CameraOCR\]WorkerenteredZoneA\.

\[CameraOCR\]SafetyVestDetected\.

### C\.3 Environment 2 \(Software Repository\) Distractors

To simulate a noisy, enterprise\-scale software engineering environment, the generator continuously injects irrelevant cloud infrastructure syslog telemetry into the agent’s terminal observations\.

#### Syslog Telemetry

Simulates passive health\-checks and CPU load warnings from disconnected remote servers running in the background\.

\[Syslog\]Server\-42CPUload:88%,RAMusage:71%

\[Syslog\]Server\-17CPUload:12%,RAMusage:45%

\[Syslog\]Server\-91CPUload:99%,RAMusage:89%

Example Corrupted Observation \(Software, 3 Events\):

LatestObservation:

CIPipelineFailedforPR\#3\.Lintererroronline42\.

\-\-\-BACKGROUNDTELEMETRY\-\-\-

\[Syslog\]Server\-42CPUload:88%,RAMusage:71%

\[Syslog\]Server\-17CPUload:12%,RAMusage:45%

\[Syslog\]Server\-91CPUload:99%,RAMusage:89%

## Appendix D\. Additional Results

Table 6:Software Repository Long\-Horizon Execution Scaling using using Gemini\-3\-Flash\. Baseline runtimes suffer catastrophicO⁡\(N2\)O\(N^\{2\}\)context collapse, whereas SKILL\.state maintains anO⁡\(1\)O\(1\)prompt footprint\.Table 7:Gemma\-4\-31b\-it Warehouse Scaling\.Table 8:Qwen 3\-8b\-it Warehouse Scaling\.Table 9:Software Repository Experiment 2 i\.e\. Noise Robustness\. Evaluation of runtime resilience to irrelevant syslog telemetry \(Condition 1\) during a 50\-step horizon using Gemini\-3\-Flash\.### \.1Software Repository State Recovery Experiment 3 using Gemini\-3\-Flash\.

Table 10:Software Repository State Recovery \(Env 2, Exp 3\)\. Comparison of hallucination lag \(recovery steps\) when the repository state is altered via unstructured alerts\.ScenarioRuntimeSuccessRecovery StepsA: Force PushPromptYes12MemoryYes8StatefulYes10SKILL\.stateYes0B: Flaky CI TestPromptYes14MemoryYes9StatefulYes11SKILL\.stateYes0C: PR ClosedAll RuntimesNoN/A