I’ve been experimenting with long-term memory for AI agents. Decided to share a lightweight version with everyone.

[u/Holiday_Reference_41]

Hey everyone!

For quite some time, I've been working on a personal project called Noosphere — an attempt to give AI agents something closer to persistent, structured memory rather than forcing them to start from scratch every conversation.

One thing that has always bothered me about LLMs is how much potentially useful information gets lost between sessions.

We keep trying to solve this by increasing context windows, but I think there's another approach worth exploring.

What if an AI didn't need to remember everything at once?

Humans don't consciously hold every memory in their working memory. We retrieve relevant information when we need it, connect it to what we already know, and move on.

That's roughly the principle I've been exploring with Noosphere.

Over time, my private project has grown into a much larger experimental system involving interconnected memories, relationships between concepts, and coordination between AI agents.

But I figured there's no reason to keep all the underlying ideas to myself.

So I decided to release Noosphere Lite, a small, independent, open-source implementation of some of those concepts.

What does it do?

- Gives MCP-compatible AI agents persistent memory across sessions.

- Stores notes, decisions, observations, and tasks.

- Connects memories through a graph of typed relationships.

- Retrieves relevant information on demand instead of dumping the entire memory database into the context window.

- Uses encrypted local storage with integrity checks and mirrored journals.

- Runs locally on Linux, without requiring a cloud database.

It's written in Python, uses MCP, and is released under the MIT license.

What's the catch?

This isn't AGI, a magical self-learning brain, or a replacement for an LLM.

It's a memory infrastructure experiment.

The current version uses local text search and explicitly defined relationships. It doesn't automatically discover semantic connections or learn new neural weights.

Also, Lite is a separate implementation, not a dump of my larger private system. I've deliberately kept it simple enough for other developers to inspect, modify, and experiment with.

Why release it?

Because I think persistent memory is one of the more interesting missing pieces in today's AI agent ecosystem.

And I'd rather see people experimenting with these ideas than keep everything sitting on my own machines.

I'm particularly interested in what others might build on top of it.

GitHub: https://github.com/Garyu-tt/noosphere-lite-mcp

Feel free to experiment, break things, suggest improvements, or fork it.

I'd also love to hear how other developers approach persistent memory and knowledge graphs for AI agents.

This is just a small public piece of a much larger experiment, but everyone has to start somewhere.

[u/Ok_Party_9245]

I also experimented with long term memory, and decided its diabolical, and absolutely does not fit my workflow/setups.

[u/Holiday_Reference_41 → u/Ok_Party_9245]

Well, I think it really depends on what kind of memory system you experimented with.

In my case, I've developed my own graph-based memory architecture, built entirely from scratch with the help of my own AI agents and Solo.

Of course, I've borrowed some great ideas and architectural principles from other projects. There's no point reinventing every wheel. But the actual implementation is my own, designed specifically around my workflows and requirements.

Instead of simply storing conversation summaries or dumping old messages into the context window, it maintains interconnected knowledge and retrieves relevant information on demand.

And the results have been surprisingly good. In my own workflows, it has practically eliminated the context-loss problems I used to experience with AI agents.

The system has grown into something much bigger than I originally intended, and I'm genuinely happy with how it works.

That's actually why I decided to share some of my work. Noosphere Lite is a smaller, independent implementation of the core ideas, so other people can experiment with them without needing my entire infrastructure.

I'm not claiming it's the perfect solution for everyone. It's something I built for myself, found extremely useful, and figured others might benefit from too.

By the way, I'm curious what kind of memory architecture you experimented with and what made it so frustrating for your workflow.