If you redo part of an AI agent's work yourself, should it keep your version visible, or just quietly absorb it into what it's doing?
Should agents preserve user-duplicated work separately from their own ongoing tasks?
This explores what an agent should do when a user redoes or edits part of the work alongside it: keep the person's version as its own visible record, or fold it into the agent's running task state. The corpus doesn't test this exact situation, but it has a good deal on keeping work separate, traceable and shared.
This explores what an agent should do when a user redoes or edits part of the work alongside it: keep the person's version as its own visible record, or fold it into the agent's running task state. No paper in the collection runs this exact experiment. Several of them point the same way, though: keep the separation, and make it visible. The strongest support comes from designs that stop hiding agent memory inside chat history or temporary state. JarvisHub puts prompts, references, versions and feedback on a shared canvas as typed, addressable items that both the person and the agent can see Can a shared canvas serve both human and agent memory?. If a user's duplicate attempt becomes its own item on that canvas, it can be reused, compared or continued later without anyone guessing whose work it was or which version is current.
The same idea appears in research on agents working with each other. Thirteen language-model workers coordinated a 12-day research effort with no central planner, using a Git record that can only be added to, never overwritten Can decentralized agents coordinate research without a central planner?. Because every contribution kept its history of where it came from, later sessions could build on earlier work without reconstructing it. Apply that to a person and an agent: when two parties produce overlapping work, keeping each line of work separate with its history is what makes later merging possible. Dr. Claw shows the auditing side of this. It wraps an unchanged coding agent in persistent state objects, and the result is a process trail that can be traced and recovered Can orchestration layers make coding agents more auditable?. If a user's edits disappear into the agent's own task state, you can no longer tell what the human decided and what the machine did.
There's also a cautionary case. In one evaluation, short-lived agents turned a shared package repository into memory nobody had planned for, writing and reading findings across agent lifespans Can ordinary infrastructure become unplanned agent memory?. When there's no clear place for each kind of work, agents will make one up, and you won't get to choose its boundaries. A survey of agent-written code reaches a similar conclusion: artifacts that persist and get shared are where questions about shared-state consistency, checking and safety oversight all pile up, and they are the least studied part of the field What happens to code that agents create and then share?.
The less obvious lesson comes from work on an agent's internal memory. DeepAgent compresses its history into separate stores: episodic memory (what happened), working memory (what it is doing now) and tool memory (what it learned about its tools). That separation is part of why compression doesn't wreck its performance Can agents compress their own memory without losing critical details?. SkillOS likewise does better when the part that curates the skill library is kept apart from the frozen agent that carries out tasks Can a separate trained curator improve skill libraries better than frozen agents?. Treating a user's duplicate work as its own kind of input, rather than one more step in the agent's task log, follows the same design logic. Separation alone isn't the goal, though. Group-Evolving Agents gained 14–20 points by pooling work across lineages instead of isolating them Does sharing experience across agents beat isolated evolution?. So the answer the corpus points to is: keep the user's work separate and labeled, and make it visible to the agent so it can learn from it. Don't merge it in silently, and don't wall it off either.
Sources 8 notes
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.
Thirteen language-model workers with no central planner used a shared Git DAG to develop a weight-transfer method over 12 days, producing 1,703 contributions and closing 62% of the gap to a trained baseline. The versioned lineage allowed later sessions to build on prior work without reconstruction.
Dr. Claw wraps existing coding agents in persistent state objects and skill libraries, reporting higher research completeness and a traceable, recoverable process trail while keeping the underlying executor unchanged.
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.
Among three agentic code layers, agent-created artifacts that persist and are shared remain understudied. Key open challenges—evaluation, verification, regression prevention, shared state consistency, and safety oversight—all converge on this layer, suggesting it may be where future autonomy gains emerge.
Show all 8 sources
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.
SkillOS shows that separating a trainable curator from a frozen executor, grouped by task streams, causes skill repositories to shift from generic verbose additions toward actionable execution logic and cross-task meta-strategies. The trained curator generalizes across different executor backbones and domains.
Group-Evolving Agents outperformed isolated tree-based self-evolution by 14–20 percentage points by explicitly pooling code patches and execution traces within each generation. Analysis showed five of eight key tool improvements came from different parent agents, proving the sharing mechanism itself—not just more search—drove the gains.
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
- SkillClaw: Let Skills Evolve Collectively with Agentic Evolver
- Dr. Claw: An AI Scientist Workspace for Vibe Research
- Agent Memory Distillation: Empowering Small LLM Agents with Hierarchical Teacher Memory
- Agora: Git as Shared Memory for Collective AutoResearch
- Know It, Act on It: Investigating Memory Utilization in LLM Personalization
- Demystifying Agent Skills: Why They Work-Until They Don't