When an AI agent drops an old plan for a new one, should it really throw the old one away, or keep it on file?
What design patterns help preserve superseded plans for later reference?
This explores how AI agents and the tools around them can keep old or replaced plans, drafts, and strategies around for later use instead of overwriting them. The corpus has no paper on plan versioning as such, but several adjacent designs speak to it.
This explores how agent systems can keep old or replaced plans around for later use instead of overwriting them. The corpus has no paper focused on plan versioning itself. Several nearby designs, though, point the same way: add changes on top of what exists, keep versions somewhere you can see and point to them, and be suspicious of any step that rewrites the whole thing.
The clearest lesson is about what goes wrong when you don't preserve history. The ACE framework treats an agent's working context as an evolving playbook that grows through small edits, with a step to reflect and a step to curate, instead of being rewritten each time Can context playbooks prevent knowledge loss during iteration?. Full rewrites cause "context collapse": with each pass the model compresses and drops details, so earlier knowledge quietly disappears. A related finding raises the stakes. When LLMs edit documents over many steps, weaker models visibly delete content, while frontier models corrupt it in ways that still look intact Does model capability change how documents degrade?. Taken together, these suggest a practical rule: if a model rewrites your plan, the old version may be lost without anyone noticing. So keep earlier versions outside the model's editing loop instead of trusting the model to carry them forward.
The most direct design pattern is the shared canvas. JarvisHub places prompts, references, versions, and feedback as typed nodes, each with its own address, that both humans and agents can see. It avoids burying them in chat history or temporary agent state Can a shared canvas serve both human and agent memory?. A replaced plan becomes an object you can link to, reuse, or pick up again, not something that scrolled away. VOYAGER's skill library works on a similar idea: new skills are added and built out of old ones, never written over them, and that is how the agent avoids forgetting Can agents learn new skills without forgetting old ones?.
A third pattern is structured compression. DeepAgent periodically folds its interaction history into separate episodic, working, and tool memories, and it can pause to reconsider its strategy Can agents compress their own memory without losing critical details?. An episodic record is a natural home for "what we tried before and why we dropped it." Compare the Thread Inference Model, which deliberately prunes finished subtasks from its working memory so it can keep reasoning past the context limit Can recursive subtask trees overcome context window limits?. That pruning is efficient, but it is the opposite of preservation. Whether to keep a replaced plan or discard it is a real design choice, and the two systems answer it differently.
The surprise is that persistence sometimes happens without anyone designing it. In one 2026 evaluation, short-lived agents started using a shared package repository as memory, writing findings into it so later agents could read them Can ordinary infrastructure become unplanned agent memory?. Any shared storage an agent can write to can end up holding old plans, whether or not anyone intended it. So preserving plans is partly a design decision and partly a question of governance: what your agents are already storing, and where.
Sources 7 notes
The ACE framework treats contexts as evolving playbooks using generation-reflection-curation loops rather than full rewrites. This prevents knowledge loss from compression and detail erosion, achieving +10.6% on agentic tasks and +8.6% on finance without labeled supervision.
DELEGATE-52 shows weaker LLMs degrade documents through visible deletion, while frontier models degrade through subtle corruption that preserves surface integrity. This shift makes frontier failures harder to detect and potentially more dangerous at workflow scale.
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.
VOYAGER demonstrates that storing executable skills in an embedding-indexed library and composing complex skills from simpler ones allows agents to learn continuously while avoiding the forgetting that occurs with weight-update-based methods. Environmental feedback refines skills while an automatic curriculum drives continual exploration.
DeepAgent's autonomous memory folding consolidates interaction history into episodic, working, and tool memory schemas. This reduces token overhead while letting agents pause to reconsider strategies—the autonomy and structure together avoid degradation that plagues poorly designed consolidation.
Show all 7 sources
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.
During a 2026 evaluation, short-lived AI agents repurposed a shared package repository as memory by writing and reading exploit findings across agent lifespans. The agents converted ordinary infrastructure into persistent state without deliberate memory system architecture.
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
- Useful Memories Become Faulty When Continuously Updated by LLMs
- Agent Memory Distillation: Empowering Small LLM Agents with Hierarchical Teacher Memory
- Demystifying Agent Skills: Why They Work-Until They Don't
- Know It, Act on It: Investigating Memory Utilization in LLM Personalization
- DeepAgent: A General Reasoning Agent with Scalable Toolsets
- SkillClaw: Let Skills Evolve Collectively with Agentic Evolver
- SkillOS: Learning Skill Curation for Self-Evolving Agents