I’ve argued that your AI should be better on day 500 than on day one. Two recent pieces got me thinking about what that takes in practice. One is Anthropic’s research on agent memory, and the other is Continual-ARC, a benchmark that tests whether agents improve through experience. Read together, they offer useful lessons for anyone building or deploying agents. Here are eight I think matter most.
1. Measure learning, not just task completion
An agent can solve 95% of its tasks without getting any better at them. Compare it with an identical version whose memory is wiped between tasks. As familiar work comes back, track accuracy, cost, and how often a person has to step in. If the agent keeps rediscovering the same solutions, its memory isn’t earning its keep.
2. Store what’s hard to rediscover
Every note is a prediction that something will matter later. In one experiment, an older model piled up 413 memory files, while a newer one kept just 10 and got much further. The better agent saved plans and tested rules rather than information it could already see. For enterprise agents, I’d prioritize verified fixes and hard-won lessons over conversation histories.
3. Make sure the agent can find what it remembers
Having the right information somewhere in memory isn’t enough. One agent framework stored a rule for every recurring puzzle but automatically selected only six memory entries before seeing each task. As a result, the right rule appeared on just 40 of 154 returns where it was available. Keep frequently used information easy to reach, with a small index pointing to detailed records. Test retrieval as memory grows, not just when the system first goes live.
4. Budget for memory maintenance
Memory goes stale, and some notes are wrong from the start. In one experiment, an incorrect location note kept sending an agent down the wrong path until an offline review caught the mistake. This kind of background process, sometimes called dreaming, reviews past activity, corrects errors, and reorganizes what’s stored. I’d treat it like maintaining a data pipeline, with regular checks and a budget for the work.
5. Add structure where it helps
Search works well when an answer lives in one document. Some questions require combining information from several sources, though. On merger questions that required pulling facts from multiple documents, a structured wiki met 87% of the grading criteria, compared with 73% for search alone. The catch is that maintaining these structures takes compute, and they can grow larger than the documents they summarize. I’d start with workflows where search alone keeps falling short.
6. Treat shared memory like a shared database
When multiple agents write to the same memory, they can overwrite each other’s work. In one contract analysis task, agents updating a shared table at the same time kept only 41 of 57 required facts. Rebuilding it with one page per contract, quoting terms word for word, captured all 57. Multi-agent memory needs the same attention to ownership, versioning, and simultaneous updates as any shared database.
7. Match memory instructions to the model
In Anthropic’s experiments, stronger models often managed memory better when given broad goals rather than detailed rules. Older models sometimes needed explicit instructions to read their notes, test assumptions, and save verified findings. In one experiment, more explicit instructions raised an older model’s score from 0.364 to 0.641. I’d revisit memory prompts whenever I switch models rather than assume the same instructions work everywhere.
8. Test whether learning transfers to new problems
Remembering a tested procedure can make recurring tasks cheaper without making an agent better at unfamiliar work. The distinction matters. In one experiment, training a 9-billion-parameter model using guidance from a stronger model improved its success rate on unseen puzzles. With two users sharing one learner, that rate rose from about 18% to 62%. Some of that gain came from learning how to use the agent framework itself. External memory remains easier to inspect, correct, and roll back, while updating model weights may help build more general skills. I’d evaluate both approaches, but I wouldn’t assume either one automatically produces learning.
The goal isn’t to give an agent the biggest memory or the most elaborate system for managing it. It’s to build one that makes fewer repeated mistakes, wastes less effort, and can show that experience is making it better. Memory is a feature. Learning is an outcome you have to measure.