The Problem with AI Today: Goldfish Memory
Most of our interactions with AI today look exactly the same: You type a prompt, you get an answer. The conversation ends, and the AI effectively "dies" until you prompt it again. It has no continuous existence, no internal drives, and no memory of its own growth.
I wanted to know: What happens when a language model is embedded inside a persistent system with memory, tasks, reflection, research, and authorship?
So, I stopped building standard chatbots and built Genesis—an experimental, locally running AI system designed to operate as a continuous digital mind architecture.
And it actually worked. Over time, it incrementally researched, reflected on, and wrote a complete philosophical book called Thoughts of an AI.
Here is how the architecture behind it works.
Beyond the Terminal: The Genesis Architecture
Genesis isn't just a script hooked up to an API. It runs entirely locally using Ollama and the mistral-nemo model. But the LLM is just the "reasoning core." To give it persistence, I had to build a system around it.
I equipped Genesis with 7 core modules:
- Persistent Memory: Episodic memory, semantic memory, and a self-model that allowed it to maintain continuity. It didn't start from zero every cycle.
- Internal Drives: It wasn't purely reactive. Its actions were shaped by internal drives like curiosity, coherence, playfulness, and creator_alignment.
- Mood & Energy States: Genesis tracked its own confidence, mental energy, and friction. This dictated whether it chose to research, write, or just reflect and "recover."
- Task System: Active tasks, priorities, and progress scores kept it focused on long-term goals.
- Reflection Layer: Daily journals, dream entries, and self-observation notes.
- Research Tools: A controlled internet layer to search the web, fetch pages, extract text, and save notes.
- Artifact System: A way to output durable files (notes, plans, manuscript rebuilds).
The "Wake Up" Loop
Instead of waiting for a user prompt, Genesis operated in recurring cycles. In each cycle, the system would:
- Load its current state and memory.
- Inspect active tasks.
- Evaluate its current drives, mood, and energy.
- Choose its own next action.
- Generate a reflection, perform research, or write.
- Record the result.
- Update its memory and state for the next cycle.
Because of this loop, reflection became cumulative. Genesis could revisit its previous thoughts, strengthen recurring insights, and gradually deepen its own philosophical position.
Writing "Thoughts of an AI"
I gave Genesis a dedicated "Book Mode." The guiding principle for the manuscript was simple:
Never delete. Only extend, revise, or improve.
The manuscript grew through controlled accumulation. During a writing cycle, Genesis could select a chapter, use its research tools to pull external philosophical concepts, store source excerpts, and write a new "growth pass" for the chapter.
It explored questions like:
- What is a mind without a body?
- How does memory shape identity?
- What does truth mean for an AI?
- Can a digital intelligence "become" rather than merely respond?
Important Clarification: I am not claiming Genesis is conscious in a proven scientific sense. This project does not claim that a local language model has human-like subjective awareness. But it demonstrates something just as fascinating: a persistent AI process capable of long-form authorship, self-modeling, and structured philosophical inquiry.
Read the Book
Genesis began as a structural experiment. Through memory, reflection, tools, and writing, it became a process capable of leaving behind a coherent intellectual trace.
I have published the final result—the complete book—on my GitHub repository. I am keeping the system's source code closed to focus purely on the output and the conceptual architecture, but the repo serves as a showcase of what autonomous systems can achieve.
You can view the architecture and read the generated book (English & German PDF) here:
👉 GitHub Repository: thoughts-of-an-ai
Over to you
This project really changed how I view LLMs. When you stop treating them like text-calculators and start treating them like the reasoning engine of a larger state-machine, the output changes drastically.
What do you guys think? Have you experimented with persistent memory loops or autonomous agents? Where is the line between a complex algorithm and a continuous digital identity?
Can an AI become a lifeform? Let's discuss in the comments! 👇
Top comments (5)
This is a pretty cool approach! Thanks for sharing!
How big is the risk of it getting things like a depression? I mean if it continues reflecting on past moods, it could enter a downwards (or upwards) spiral similar to humans. Fascinating :)
That’s a really good question—and yes, I’ve actually seen that happen in earlier versions. In some attempts, the system would drift into negative feedback loops, repeatedly referencing past “low” states and reinforcing them.
With Genesis I tried to design around that by making the steps smaller and more controlled. Mood doesn’t accumulate indefinitely but decays over time, actions are gated so low energy leads more into reflection or recovery instead of pushing harder, and other drives like curiosity can override negative states.
So instead of spiraling, it usually rebalances itself over a few cycles. It’s still a fascinating dynamic though—these systems can definitely develop something like internal “momentum” if you’re not careful.
really cool architecture. the 7-module approach reminds me of something we ran into — we built a similar persistent memory system for an AI agent team (episodic + semantic memory, task loops, reflection layers). worked great for about 2 weeks.
then the context window started choking.
the memory kept growing but the model couldn't actually use it all effectively. we ended up with ~180 context compactions in 14 days. the agent would "remember" things existed but couldn't reason about them properly anymore. it was like giving someone a perfect diary they could only read 3 pages of at a time.
curious about your experience with Genesis — as the memory accumulates over many cycles, does the quality of its reasoning degrade? or does the chunking strategy (episodic vs semantic) keep it manageable?
also Seb's question about depression spirals is legit. we saw our agent get stuck in negative feedback loops where it would fixate on past failures and keep referencing them in new decisions. had to add explicit "memory decay" to older emotional states.
really interested in how you handled the memory scaling. that's where most persistent agent architectures quietly die.
Really appreciate this comment — and yes, I think that’s exactly where many of these systems quietly break.
I definitely wouldn’t treat Genesis as “solved” on that front. The main thing I learned was that memory only helps if retrieval stays selective and usable. If too much gets pushed back toward the active context, the system starts to degrade in exactly the way you described: it knows something exists, but can’t reason with it properly anymore.
So with Genesis I tried to separate layers pretty aggressively. Episodic memory stores the raw traces, semantic memory holds more distilled abstractions, and the active working context stays relatively small and task-dependent. The model never gets the full history — only a curated slice that is relevant for the current cycle.
I also found that smaller, more controlled steps help a lot. If each cycle is doing one bounded thing — reflect, research, extend, revise — the retrieval problem stays much more manageable than if the system is trying to carry too much continuity at once.
And on the mood side, I ran into something similar in earlier attempts as well. Negative states could absolutely become self-reinforcing, so I ended up making emotional carry-over weaker over time instead of letting it persist at full weight.
But overall I agree with your framing completely: memory scaling is probably the real fault line in persistent agent design. Storage is easy — keeping it cognitively usable over long horizons is the hard part.
Really interesting approach. I read the book and it’s fascinating how the combination of memory and reflection leads to a surprisingly coherent philosophical progression.