Instead of passing work between a planner and a writer, could an AI keep one shared notebook for both?
Can unified state objects replace switching between decomposition and writing tools?
This explores whether an agent can keep one shared, persistent record of the work (plan, drafts and history together) instead of handing off between a tool that breaks the task apart and a tool that produces the output.
This explores whether an agent can keep one shared, persistent record of the work (plan, drafts and history together) instead of handing off between a tool that breaks the task apart and a tool that produces the output. The corpus has no head-to-head test of that swap. The closest evidence points to a split answer: a unified state can remove the hand-offs, but the separation between planning and doing still does real work.
The case for unified state is that the seam between tools is where context gets lost. Prime Agent keeps its state in four levels, from weights to context to a persistent REPL to disk-backed history. That lets the model read and write addressable state well beyond its instruction stream, and it makes harness failures easier to tell apart from model failures. It reported gains on ARC-AGI-3, though the individual components weren't ablated (Can external state caches let models solve harder problems?). JarvisHub does the same for people and agents together. Prompts, references, versions and feedback are typed nodes on one canvas that both can see, so work can be updated locally and unfinished pieces picked up again without the process being hidden in chat (Can a shared canvas serve both human and agent memory?). In both designs, a plan and a draft are two kinds of object in the same place, not outputs of two different tools.
Decomposition can also move inside the state instead of sitting next to it. The Thread Inference Model treats reasoning as a recursive tree of subtasks and prunes the KV cache as branches finish. One model can then run the whole recursion, which replaces a multi-agent setup (Can recursive subtask trees overcome context window limits?). Atom of Thoughts goes further: the problem is a graph that keeps contracting, and each state depends only on the current problem, not on the steps that got there (Can reasoning systems forget history without losing coherence?). Here decomposition is no longer a tool you switch to. It is the shape of the state.
The separation itself is more than plumbing, though. Splitting a decomposer from a solver improves accuracy, and the two skills behave differently. Decomposition transfers across domains, solving doesn't, and keeping them apart prevents planning from interfering with execution (Does separating planning from execution improve reasoning accuracy?). ReWOO and Chain-of-Abstraction plan first and leave placeholders for tool results, which cuts the quadratic prompt growth and sequential waiting that come from interleaving (Can reasoning and tool execution be truly decoupled?). LLM Programs get their gains by hiding everything a step doesn't need (Can algorithms control LLM reasoning better than LLMs alone?). So the takeaway is that one object should hold the storage, while each step still sees only its own slice. A single object that every step reads in full brings back the interference the split was preventing.
A unified state also isn't free. The long-context bottleneck appears to be the compute needed to turn stored context into usable internal state, not the capacity to store it (Is long-context bottleneck really about memory or compute?). Models with a fixed-size latent state provably can't copy or retrieve exactly the way transformers can (Can state-space models match transformers at copying and retrieval?). That favors an external state you look things up in over one you hope the model compresses. There is one side benefit. Per-action checks can't express rules about sequences, and only a stateful monitor can catch individually fine steps that add up to a violation (Can stateless checks ever catch sequence-level constraint violations?). A single record of the work gives such a monitor something to watch.
Sources 10 notes
Prime Agent organizes persistent state in four levels (weights, context, persistent REPL plus subagents, disk-backed history) to let models read and write addressable state beyond their instruction stream. The approach isolates harness failures from model failures and reported gains on ARC-AGI-3, though specific components remain unablated.
JarvisHub proposes that placing prompts, references, versions, and feedback as typed canvas nodes visible to both users and agents—rather than hiding agent memory in chat or transient state—enables local updates, artifact reuse, and unfinished work continuation without process opacity.
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.
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.
Modular architectures with separate decomposer and solver models outperform monolithic LLMs, with decomposition ability transferring across domains while solving ability does not. The separation prevents planning-execution interference and produces more generalizable skills.
Show all 10 sources
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.
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.
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.
Two-layer transformers can copy exponentially long strings while state-space models are fundamentally limited by their fixed-size latent state. Empirically, transformers dramatically outperform SSMs at copying and context retrieval in both synthetic and pretrained settings.
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.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- From Model Scaling to System Scaling: Scaling the Harness in Agentic AI
- Efficient Tool Use with Chain-of-Abstraction Reasoning
- Divide-or-Conquer? Which Part Should You Distill Your LLM?
- Recursive Language Models
- Beyond Context Limits: Subconscious Threads for Long-Horizon Reasoning
- Hogwild! Inference: Parallel LLM Generation via Concurrent Attention
- Demystifying Chains, Trees, and Graphs of Thoughts
- The Illusion of Thinking: Understanding the Strengths and Limitations of Reasoning Models via the Lens of Problem Complexity