Memory Is the Constraint

A context window fills. A new session begins. The system needs some way to carry the work forward.

Anthropic's work on long-running coding agents handles that break with progress files, Git history, and structured handoffs. Google Research's Nested Learning treats memory as a set of processes that update at different rates. Yan and colleagues' Memory-R1 goes further by training a separate manager to add, update, delete, or ignore information in an external memory bank.

Across those projects, persistence depends on a rule that decides which information survives into later work.

What the next session can actually use

An archive can preserve every conversation and still leave the next agent unable to continue the work. The useful state is the smaller set that changes what the system notices, expects, or does next.

That distinction already appears in products. A transcript records what happened. A project brief carries current decisions. A permission tells the system what it may do. Mixing them in one undifferentiated memory store hides which of those states the next action may use.

Once a product team starts keeping any of that state, it has to say what kind of memory it is, who or what may use it, and when it expires. A saved fact should also show where it came from.

Selection creates a governance problem

Every memory system has a rule for what survives. Today that rule usually comes from a prompt, a retrieval score, or an application policy. The surrounding product is doing the choosing.

Yan and colleagues change the mechanism by training a manager to edit the bank, which leaves the governance question in place. A system that can rewrite its own memory can also preserve a bad assumption or carry a poisoned instruction into future work.

Memory editing is an action with consequences. High-impact changes need a record and a way to reverse them. The system should never be the only judge of whether its own memory remains accurate.

What belongs in the interface

A usable memory surface should answer ordinary questions:

• What was kept?
• Where did it come from?
• What can use it?
• When will it expire?
• What changed because it was remembered?

The interface can keep embeddings and retrieval scores internal. The policy that affects future behavior has to stay visible, because that is the part that changes what the system does next.

For a personal agent, that could be a memory ledger with clear scope and deletion controls. For a work agent, it could be a project state that separates approved decisions from provisional notes. In either case, the person needs to see when the system turns an interaction into durable state.

Self-maintenance is still a test

The working paper follows the point where a system begins preserving information because later operation depends on it. That retained state starts to support continuity across tasks. The paper calls this limited capacity self-maintenance. The term marks a testable change in how state persists. It does not name a product that exists today, and it does not claim consciousness.

Current memory products do not establish that transition. Anthropic's harness still governs continuity from outside. Nested Learning describes processes that update at different rates; it does not show a product deciding what to keep because later operation depends on it. Memory-R1 trains a manager, still under an external objective. What those systems do make clearer is the practical risk: the information that stabilizes future behavior becomes the information an attacker would want to change.

Until a person can see what was kept, limit who may use it, edit it, and delete it, a memory store should not expand what the agent is allowed to do.

Sources

• Anthropic. Effective harnesses for long-running agents, 2025.
• Google Research. Introducing Nested Learning, 2025.
• Yan, S., et al. Memory-R1: Enhancing Large Language Model Agents to Manage and Utilize Memories via Reinforcement Learning, 2025.

The full Constraint, Capacity, and Self-Maintaining Agency working paper develops the systems framework and the tests that could disprove it.