Show HN: A persistent AI runtime I started building after realizing LLMs forget everything

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!

APSW in Colour (Async) – Another Python SQLite Wrapper