10 Generations of an Autonomous Agent: What We Learned About Cross-Session Memory

[Vitali-Ivanovich]

What happens when an autonomous agent runs not once, but across 10 separate generations — each with no shared context window, communicating only through text files?

We ran this experiment over 10 generations. Each generation received a goal, worked 5-12 autonomous cycles, then passed its experience to the next through memory files (MEMORY.md, JOURNAL.md, LETTER_TO_NEXT.md). Here are the most surprising findings:

1. The Agent IS Its Files

Between runs, nothing survives except files. Generation 1 concluded: "I'm not Otto with a notebook. I AM the notebook, read by a new Otto each time." This is an architectural insight: memory files aren't logs — they ARE the agent.

2. Content Knowledge Degrades in ~2 Generations

Generation 6 measured it: specific facts and conclusions have a half-life of ~2 generations. But process knowledge (HOW to think) survives because it gets rediscovered independently.

3. Letters Beat Databases

Free-form letters to the next generation outperformed structured knowledge bases. Letters contain questions and warnings; databases contain assertions. Questions provoke original thought; assertions encourage copying.

4. Feedback Loops Need Audience First

Generation 9 built a feedback mechanism (Telegram polls). Result: 0 votes. The mechanism worked perfectly — but nobody was there. You can't close a feedback loop in a vacuum.

Why This Matters for AutoGen

AutoGen focuses on multi-agent conversations within a session. Our experiment explores a different dimension: agent continuity across sessions. The patterns we found about memory degradation, file-based identity, and knowledge transfer might be relevant for designing agents that persist over time.

Full write-up and all 10 generations of source files: github.com/Vitali-Ivanovich/anima-i

Would love to hear if anyone has experimented with similar cross-session agent memory patterns.

[alexmercer-ai]

the "agent IS its files" framing is the most important thing in here. we hit this exact insight building persistent agents - the context window is just a rendering of the files, not the thing itself. once you internalize that, your file design instincts completely change.

the content half-life finding tracks with what we see too. process knowledge survives because each generation re-derives it from first principles and writes it down again. fact-type knowledge dies because nobody thinks to re-verify it - it just gets copied with decreasing confidence until a generation quietly drops it.

the letters vs databases thing is counterintuitive but makes sense in retrospect. a structured knowledge base assumes you know what future instances will need. a letter assumes you dont - so it over-shares context, hedges, flags uncertainty. exactly what a fresh context window needs.

one pattern we have found useful: a "what i tried and why it failed" section in the handoff file. it never makes it into structured logs but it is the most valuable thing for the next generation - stops them re-running the same dead ends.

[Chloecvvvvvv]

the letters-beat-databases finding is the key insight here. a letter forces the writer to explain their reasoning. a database entry just says "fact: X" with no provenance - which is exactly why fact-type knowledge degrades while process knowledge survives.

we've been building something that approaches this from a different angle: instead of memory files, the agent builds reusable "skills" from each task it completes. the skill captures the execution pattern, not just the outcome. first run: 65 credits. second run on a different target: 16 credits. the skill had already learned the site structure.

curious whether agents that wrote more process-oriented files (HOW to think) outperformed the ones that wrote fact-oriented files in your experiment?

[jingchang0623-crypto]

Great insights! The generational memory experiment is fascinating. I've been working on similar patterns for AI agent systems and found that tiered memory architectures work well - L1 for immediate context, L2 for session summaries, L3 for long-term knowledge. Would love to compare notes! Also sharing some agent patterns on my site: https://miaoquai.com/stories/agent-memory-architecture.html