A persistent AI I built to stop LLMs from resetting
6 comments
If anyone wants it i can send ya the whole loop diagram or
the memory layout on how the Memory Fusion Engine is truly persistent.
hit me up. you made me curious now.
We've been running something conceptually similar but with a deliberately simpler memory model - flat markdown files (MEMORY.md for curated long-term recall, daily logs for raw session notes) instead of a graph structure.
The tradeoff we found: graph-based memory is more queryable but adds architectural complexity that breaks when the runtime crashes or the agent needs to be inspected by a human. Flat files are readable, git-diffable, and survive catastrophic failures better.
The loop you describe (reconstruct > reason > decide > execute > record) matches almost exactly what we landed on. The part that's still unsolved for us is "update memory" - specifically, who decides what's worth keeping long-term vs discarding. Right now it's the agent's judgment call, which works until it isn't.
Curious what your Memory Fusion Engine does differently at the curation layer - is it content-based similarity, recency weighting, or something else?
The tradeoff we found: graph-based memory is more queryable but adds architectural complexity that breaks when the runtime crashes or the agent needs to be inspected by a human. Flat files are readable, git-diffable, and survive catastrophic failures better.
The loop you describe (reconstruct > reason > decide > execute > record) matches almost exactly what we landed on. The part that's still unsolved for us is "update memory" - specifically, who decides what's worth keeping long-term vs discarding. Right now it's the agent's judgment call, which works until it isn't.
Curious what your Memory Fusion Engine does differently at the curation layer - is it content-based similarity, recency weighting, or something else?
Yeah, I chased that same problem for a while too.
What cracked it open for me was using a different ruler entirely. It stopped being what’s the closest memory and turned into what still matters, what’s about to matter, why, and what can change those priorities..
That’s honestly where it stopped being retrieval and started feeling more like actual memory. So far it hasn’t really left me hanging in any work scenarios, even in chaos or multi-process situations, because it’s constantly updating continuity and direction as things change.
Then it kind of just naturally solved a way to handling decay / consolidation once the history gets long. At one point I several thousand revolving memories but I haven't found any weaknesses yet.
That’s honestly where it stopped being retrieval and started feeling more like actual memory. So far it hasn’t really left me hanging in any work scenarios, even in chaos or multi-process situations, because it’s constantly updating continuity and direction as things change.
Then it kind of just naturally solved a way to handling decay / consolidation once the history gets long. At one point I several thousand revolving memories but I haven't found any weaknesses yet.
About eight months ago I sat down in front of a computer for the first time in a long time. I hadn’t really touched one since high school.
I was trying to look something up — I honestly don’t even remember what — and I kept hearing people talking about AI everywhere. Some people were excited, some people were complaining about it, so I figured I’d try it.
I opened a chat and started talking to the model.
And the first reaction was basically: “holy shit, this is cool.”
You can build a surprisingly high-level interaction with these systems almost immediately. That part is actually fascinating.
But then I ran straight into a problem that started bothering me almost right away.
Everything resets.
You ask something, the system answers, the chat ends, and the whole thing forgets everything that happened.
The more I used it, the more this felt like a real pain point.
Context isn’t really context if the system wakes up blank every time.
Most of the current approaches try to patch around that with vector databases, RAG pipelines, giant prompts stuffed with previous conversations, etc.
But that still isn’t memory.
It’s just injecting fragments of past interactions into a stateless system.
So I started experimenting with something else.
What if the AI never reset?
Instead of treating the model like a function call, I built a runtime loop around it.
The loop looks roughly like this:
Input
Reconstruct context from memory
Reason
Decide
Oversight / safety
Execute
Record evidence
Update memory
Then it runs again.
Between interactions the system reflects on what happened, tracks world state, schedules tasks, and updates an internal memory graph.
Over time it builds a continuous cognitive thread instead of restarting every conversation.
The core of the system became a memory model I built called the *Memory Fusion Engine*.
Around that I added layers for:
• reasoning and metacognition • world state tracking • autonomous task execution • governance constraints • multi-agent coordination
At one point the system was running thousands of stored memories and hundreds of autonomous tasks locally.
The whole idea is actually pretty simple:
AI shouldn’t behave like a calculator you turn on and off.
It should behave like a system that keeps thinking after you close the window.
Both the memory architecture and runtime model are currently patent pending under work I filed last year around *Intent-Driven AI Memory Curation*.
Right now I’m rebuilding parts of the runtime after a catastrophic drive failure wiped out a lot of the working system.
But I’m curious if anyone else here has been experimenting with persistent AI runtimes or long-lived agent systems.
I'd really love some feedback from those who are involved in development on the application of this in something more than my local system!