Persistent projects make agent memory a software-state problem

Cursor’s September 10, 2026 Projects release put persistent shared context at the center of long-running agent work. The company described projects that retain information across local and cloud sessions and support work divided among subagents. That moves the product beyond remembering a chat preference: the agent must keep track of an evolving codebase, unfinished work, and decisions made by several participants. The difficult question is which remembered information is still true when the next session begins. Cursor introduces Projects.

Memory promises an agent that becomes more useful with experience. It also creates a place for outdated assumptions to survive. A saved preference, a former policy, and a successful procedure have different lifetimes. Treating them as interchangeable text can make an autonomous system confidently repeat something that was only appropriate in an earlier context.

Lost in the Middle, first submitted July 6, 2023, studied how language models used information within long contexts. It reported performance sensitivity to where relevant material appeared in the evaluated inputs. The finding concerns those models and tests; it is a warning to evaluate retrieval, not a timeless limit on all context windows. Lost in the Middle paper.

Remember with provenance

In our analysis, memory should retain who supplied a fact, when it was established, and the conditions under which it applies. A hypothetical agent handling travel preferences should distinguish a permanent accessibility requirement from a temporary choice made for one trip. Compression that removes that distinction can turn convenience into an avoidable mistake.

Voyager, submitted May 25, 2023, used a library of executable skills in a Minecraft agent. Its research illustrates that reusable memory can include procedures rather than only conversation summaries. Success in that environment should not be generalized directly to enterprise systems. Voyager paper.

Retest what gets reused

We would give procedural memories tests and factual memories review conditions. When an application changes, previously successful procedures should be revalidated. When evidence conflicts, the agent should surface the conflict rather than silently choose the older entry. Memory supports autonomy when it preserves useful experience together with the information needed to decide whether that experience still applies.

The earlier harness problem was concrete

Anthropic’s November 26, 2025 engineering account reported two recurring failures in long-running application development: agents attempting too much in one session, and later sessions declaring the job complete too soon. Its solution separated an initializer from subsequent coding sessions, using a feature list, progress file, and Git history to carry work forward. It also described browser-based testing because edits and unit tests alone could miss a broken user-facing feature. These were observed problems in the company’s experiments, not hypothetical objections to agents. Anthropic effective long-running harnesses.

A memory is not the thing it describes

That history makes persistent projects easier to understand. Memory can preserve a claim that a feature works, but the repository is the evidence of what was implemented. A progress note can preserve the intention to rename an API, but the current references reveal whether the migration finished. The agent needs both narrative continuity and access to the actual state of the work. Relying on only one creates predictable blind spots.

This is also where long-running autonomy differs from a long context window. More room for old messages can help, yet it can preserve obsolete assumptions with the same apparent authority as current facts. A feature may have been removed, a test may have changed, or a teammate may have revised the plan. The useful memory system must support correction and replacement, not just accumulation.

Context engineering supplies the bridge

In September 2025, Anthropic described Claude Code’s combination of upfront project instructions and just-in-time file retrieval. Its engineering account also discussed compaction, structured notes, and subagents with separate context windows. The common principle was to retain references and relevant state while retrieving detailed material when needed. That approach makes memory an active process of selection. It also introduces a cost: the system must decide when to trust a summary and when to return to the underlying file. Anthropic context engineering.

Projects turn continuity into a competitive claim

For a developer, the value of a persistent agent is not that it can repeat an earlier conversation. It is that useful work resumes without repeating the investigation. That could shorten a migration, keep a design decision consistent across files, or help another agent start from a reliable account of what remains. But continuity becomes harmful when it confidently carries an error into every subsequent session.

The strongest form of project memory therefore resembles maintained software state more than a diary. It has an owner, a relationship to concrete artifacts, and a way to mark earlier information as superseded. The model can help maintain that state, but its prose should not silently become the only record of completion. A test result tied to a particular revision says something a timeless note cannot.

Cursor’s Projects release and Anthropic’s harness experiments describe complementary parts of the same transition. One packages continuity as a product; the other exposes why continuity is difficult. Together they suggest that the next major improvement in autonomous coding may come as much from preserving and refreshing the right state as from generating better individual edits. The frontier is not simply how long an agent can run. It is how much correct, recoverable progress survives after it has run.

The research behind the release

Voyager’s May 2023 Minecraft research stored executable skills in a growing library and used feedback to refine behavior. Its memory was therefore not merely a transcript of earlier play; it included reusable code. The comparison helps separate kinds of persistence in enterprise agents. Remembering that a task was attempted, remembering why it failed, and retaining a working procedure are distinct capabilities. A project product may need all three, but they should not be collapsed into one claim of long-term memory. The durable value comes when a retained artifact remains applicable and can be checked against the current environment. Original research paper.