We need to talk about something the AI industry keeps dancing around: agents forget everything.
Not in the charming, absent-minded professor way. In the "hired five contractors in a row who never read the brief" way. Anthropic just published research on what they're calling "long-running agents"—AI systems meant to work across multiple sessions, multiple context windows, multiple days. The findings are less breakthrough and more confirmation of what anyone deploying agents already suspected: we're building systems that reset their memory every few hours like some kind of corporate Memento.
The core problem is embarrassingly straightforward. Claude, GPT, whatever your flavor—these models work in discrete sessions. When one session ends and another begins, the agent starts fresh. Zero institutional memory. It's the equivalent of staffing your entire engineering team with people who show up for their shift having never spoken to the person before them. No handoff notes. No git history review. Just vibes and hope.
Anthropic's solution involves what they're calling a two-agent system: an initializer that sets up the environment on first run, and a coding agent that makes incremental progress while leaving breadcrumbs for its future self. Think of it as building a very elaborate filing system for an amnesiac.
Here's what they learned: without intervention, even Opus 4.5 fails at something as conceptually simple as "build a clone of claude.ai." The model tries to one-shot the entire application, runs out of context mid-implementation, and leaves half-finished features with no documentation. The next session starts cold, wastes time debugging what happened, and occasionally just declares victory prematurely because some features exist now.
The fix involves remarkably human engineering practices. The initializer agent creates a feature list—over 200 items in the claude.ai example—all marked as "failing." It writes an init.sh script. It makes an initial git commit. It creates a progress file called, with no irony whatsoever, claude-progress.txt.
Every subsequent coding session follows a ritual: check the directory, read git logs, read progress files, pick one feature from the list, work on it incrementally, test it properly, commit the changes, update the progress file. Don't move on until the feature actually works end-to-end.
This is not sophisticated AI architecture. This is what junior developers learn in their first week. The remarkable part is that frontier models need it explicitly spelled out.
The testing problem deserves special attention. Claude kept marking features complete without proper verification—making code changes, running curl commands, even writing unit tests, but failing to recognize the feature didn't work in actual use. Anthropic's solution was browser automation through Puppeteer, forcing Claude to test like a human user would. The model took screenshots. It clicked buttons. It verified state changes. Performance improved dramatically.
But limitations remain. Claude can't see browser-native alert modals through Puppeteer. Features relying on those modals stayed buggier. The model's vision capabilities hit walls. The tools hit walls. We're not dealing with a reasoning problem anymore—we're dealing with an infrastructure problem.
What Anthropic's research really documents is the gap between "this model can code" and "this model can ship production software." That gap is currently filled with elaborate scaffolding: specialized prompts, structured file systems, explicit testing protocols, git commit discipline. All the practices that keep human engineering teams functional.
The open questions they list at the end are telling. Would specialized agents—testing agent, QA agent, cleanup agent—perform better than one general-purpose coding agent? Can these patterns generalize beyond web development to scientific research or financial modeling? These aren't rhetorical questions. They're admissions that we're still figuring out the basics.
For enterprise teams evaluating agent deployment, this research is less roadmap and more reality check. Yes, agents can build things. No, they won't do it unsupervised. Yes, you can get production-quality output. No, you won't get it by just feeding GPT-4 a prompt and walking away.
The future of AI agents apparently looks a lot like the present of human engineers: rigorous process, clear documentation, incremental progress, proper testing. We thought we were building something that transcended those constraints. Instead, we're learning they exist for good reason.