When an AI picks up where earlier steps left off, does it reread everything or just a curated slice?
How do later workloads operationally act on inherited state from earlier ones?
This explores what happens mechanically when a later step, turn, or task in an AI system picks up what earlier ones left behind: does it re-read everything, or work from something narrower?
This explores what happens mechanically when a later step, turn, or task in an AI system picks up what earlier ones left behind: does it re-read everything, or work from something narrower? Across the corpus the answer is consistent. Later work almost never acts on the full inherited history. It acts on a curated slice, and the interesting design question is who or what does the curating.
The first approach is to hide most of it. LLM Programs put an ordinary algorithm in charge of state and control flow, and each model call sees only the context relevant to its own step Can algorithms control LLM reasoning better than LLMs alone?. The Thread Inference Model does something similar inside a single model. Reasoning is organized as a tree of subtasks, and when one finishes, fixed rules prune its cache entries so the parent carries forward only what it needs. This keeps reasoning accurate past the context limit, even while manipulating 90% of the cache Can recursive subtask trees overcome context window limits?. Atom of Thoughts goes furthest. Each reasoning state is rebuilt to depend only on the current, simplified problem, not on the path that produced it Can reasoning systems forget history without losing coherence?.
The second approach is to pass state by reference. ReWOO and Chain-of-Abstraction have later steps act on earlier results through placeholders. The plan is written first and the tool outputs are slotted in as they arrive. That avoids replaying every observation into every prompt, which otherwise makes prompts grow quadratically Can reasoning and tool execution be truly decoupled?. Chain-of-thought is the opposite extreme. A feedforward transformer has no native way to carry evolving state forward, so it writes that state out as tokens so the next step can read it. That works, but it is a costly patch Why do transformers need explicit chain-of-thought reasoning?. A related finding recasts the long-context problem as one of compute. What limits performance is the work needed to turn evicted context into internal state, and more consolidation passes help Is long-context bottleneck really about memory or compute?.
The third approach is to gate what gets stored, then be selective about how it is read back. Long workflows degrade when agents replay transcripts or retrieve memory with no control over writes. The fix is a small, schema-governed committed state that separates temporarily recalling an artifact from permanently writing it to memory, which stops errors and drifting constraints from piling up Can agents fail from weak memory control rather than missing knowledge?. On the read side, PRAXIS indexes procedures by the current environment state and the action taken there. A later web task pulls the click-level step that matches where it is, not a vague workflow summary Does state-indexed memory outperform high-level workflow memory for web agents?. MRAgent skips fixed retrieval and rebuilds memory on demand. It walks a memory graph while reasoning and prunes paths as evidence accumulates, gaining up to 23% on reasoning tasks Can agents reconstruct memory on demand instead of retrieving it?.
Inherited state also includes rules, and this is where the safety angle appears. A check that looks only at the current action cannot state a constraint that depends on history, so it misses actions that are each fine alone but together break a system-level rule. Catching those takes a stateful monitor Can stateless checks ever catch sequence-level constraint violations?. One persistent agent logged 889 governance events over 96 days because its safeguards lived in the memory layer it actually consulted while deciding Can governance rules embedded in runtime memory actually protect autonomous agents?. Inherited state only shapes later behavior if it sits where the next step looks.
Sources 11 notes
The Thread Inference Model demonstrates that reasoning structured as recursive subtask trees with rule-based KV cache pruning sustains accurate reasoning beyond context limits, even when manipulating 90% of the cache. This enables single models to replace multi-agent systems by handling full recursive reasoning internally.
LLM Programs embed LLMs within explicit algorithms that manage control flow and state, presenting only step-specific context to each LLM call. This information hiding addresses capability and context window limits while treating complex reasoning as modular, debuggable sub-tasks.
ReWOO and Chain-of-Abstraction both decouple reasoning from tool responses through different mechanisms—planning-before-execution and abstract placeholders respectively—eliminating quadratic prompt growth and sequential latency while maintaining reasoning quality.
Research shows the bottleneck is not memory capacity but the compute required to consolidate evicted context into fast weights during offline sleep phases. Performance improves with more consolidation passes, following a test-time scaling pattern on harder reasoning tasks.
Agent performance degrades in long workflows because transcript replay and retrieval-based memory lack gating mechanisms. A bounded, schema-governed committed state that separates artifact recall from permanent memory write prevents error accumulation and constraint drift.
Show all 11 sources
Per-action checks are structurally unable to state constraints that depend on prior history. Only stateful monitors tracking composed multi-party behavior can verify the behavioral envelopes that prevent individually permissible actions from collectively violating system-level safety.
PRAXIS shows that indexing procedures by environment state and local action pairs yields consistent accuracy and reliability gains across VLM backbones on the REAL benchmark, compared to higher-level workflow abstractions that lose click-by-click specifics.
A persistent agent recorded 889 governance events across 96 active days, with safeguards encoded directly into the memory layer the agent consulted during operation. Runtime-resident governance proved more effective than external policies because the agent actually accessed it during decision-making.
Atom of Thoughts decomposes problems into DAGs and contracts them iteratively, ensuring each state depends only on the current problem—not prior steps. This memoryless approach eliminates historical baggage that bloats reasoning while maintaining answer equivalence.
MRAgent achieves up to 23% gains on reasoning tasks by reconstructing memory through active graph traversal that prunes paths based on accumulated evidence, while reducing token and runtime cost compared to fixed-retrieval pipelines.
Feedforward transformers lack native recurrent state-tracking and must push evolving state deeper into layers, eventually exhausting depth. Explicit chain-of-thought externalizes this state into tokens as a costly patch for a structural deficiency.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- GateMem: Benchmarking Memory Governance in Multi-Principal Shared-Memory Agents
- From Model Scaling to System Scaling: Scaling the Harness in Agentic AI
- Are We Ready For An Agent-Native Memory System?
- Agent Memory Distillation: Empowering Small LLM Agents with Hierarchical Teacher Memory
- Useful Memories Become Faulty When Continuously Updated by LLMs
- Why Do Multi-agent LLM Systems Fail?
- Efficient Tool Use with Chain-of-Abstraction Reasoning
- Demystifying Agent Skills: Why They Work-Until They Don't