u/cutesophie

I’ve been building Noosphere, an open-source memory/wiki layer for AI agents, mostly because I kept running into the same problem: long-term context is useful, but it gets messy quickly when it is only hidden embeddings or scattered notes.

After a slightly unreasonable number of late nights, I’m trying to get outside feedback from people who build or use agent systems.

The current direction is: structured Postgres-backed memory, Redis-cached recall, human-editable wiki pages, confidence/status metadata, revision history, conflict handling, and a draft → curated workflow. There are plugins for OpenClaw, OpenCode, and other agent systems, plus an API for custom integrations.

I needed such a memory system for my own projects, this was one of the reasons I had to build it.

The repo is open, and I’d really appreciate critique, contributors, or blunt feedback on what should be simpler. And general discussion here :)

Repo is on GitHub.

I've been tinkering with Noosphere, an open-source memory/wiki layer for AI agents, and I’d really like outside opinions from people building agents or dealing with long-term context.

It has consumed an unreasonable amount of sleep, so now I’m trying to find out if the idea is actually useful. xD

The basic thought: agent memory should not just be hidden embeddings or scattered notes. I’m experimenting with Postgres-backed memory, Redis-cached recall, human-editable wiki pages, confidence/status metadata, revision history, conflict handling, and draft → curated memory. There are plugins for Kilocode and other agent systems, plus an API. (Kilocode etc is easy script based for install).

Mostly looking for honest input: Repo is open, and I’d love critique, contributors, or “this is too much, simplify it” feedback.

Repo is on GitHub, see my comment :)

I’ve been hacking on an open-source agent memory/wiki project called Noosphere, and I’m trying to sanity-check the direction with people who build or use agents. Had to b sacrifice a lot of sleep. xD

The idea is memory that is not just a hidden vector store or a pile of notes: Postgres-backed structure, Redis-fast recall, human-editable wiki pages, confidence/status metadata, revision history, conflict handling, and draft → curated memory. Plugins for Openclaw and more available, or use the API

I’m mainly looking for honest input, not hype:

• What should agents actually remember long term?

• How should stale or conflicting memories be handled?

• Would human-editable memory matter to you?

• What would make this worth contributing to?

The repo is open and I’d love contributors, critique, or other feedback here. :)

Repo and more info on GitHub. See my comment.

Hey folks,

I’ve been working on Noosphere, a memory and knowledge layer for Humans and AI agents alike. The short version: I wanted agent memory that is durable, inspectable, editable by humans, and useful across different agent systems, not just a hidden pile of embeddings that may or may not appear in the prompt when the model feels inspired. I needed this system for large projects of mine and current systems didn't fit my needs. So put in countless sleep deprived nights to get this ready. OpenCode plugin available (and other agent system). General access from anywhere can be realized via API 😃

A lot of LLM memory tools focus on “save stuff, search stuff.” Useful, yes. But in practice, agent memory gets messy fast: snippet recalls, duplicate memories, stale facts, contradictions, missing provenance, token budget explosions, and the classic “I remember your preferred indentation style but forgot the entire database schema” moment.

Noosphere tries to solve that by a recall engine and treating memory more like a living wiki-like system. The project was started before I found out about Karpathys wiki paper, so it differs from his approach:

• Postgres-backed memory instead of scattered Markdown files: Noosphere uses PostgreSQL as the structured source of truth, so memories can have metadata, access scopes, status, confidence, relations, revision history, and reliable querying. Markdown still exists where it belongs: import/export, Obsidian sync, and human-friendly editing. A user requested this feature so I build it.
• Human-readable wiki memory: topics, tags, article relations, confidence levels, status lifecycle, revision history, soft delete, Markdown rendering, images, and Obsidian sync.
• Agent-ready recall: provider abstraction, concurrent multi-provider recall, ranking, deduplication, conflict detection, and prompt-safe token budgeting.
• Multi-provider memory orchestration: Noosphere can compose recall across Noosphere, Hindsight, and future providers instead of assuming one memory backend rules them all.
• Upload images support: you or the agents can upload images. This is unique, afaik no other memory system can do this.
• Memory maturity model: memories can move from ephemeral → managed → curated, instead of every random fact being treated as equally sacred.
• Promotion and backfill: repeatedly useful memories can become review candidates, and older material can be synthesized into durable articles.
• Cross-system support: plugins/integrations for OpenClaw, Hermes Agent, Opencode, and Kilo Code, plus a REST API for everything else.
• Scoped access: API keys can be permission-scoped, and restricted articles can stay restricted.

The part I care about most is auditable memory. If an agent pulls something into context, I want to know where it came from, how trustworthy it is, whether it conflicts with other memory, and whether a human can fix it without diving into a mysterious vector-store basement.

I also think agent memory should sit somewhere between fully automatic and fully manual. Auto-recall is useful, but auto-saving every bad assumption forever is how you give bugs immortality. Noosphere’s approach is to capture useful memory, keep new saves as drafts, and let important knowledge mature through review and promotion.

I appreciate any contributions here and on the repo. I’d love feedback from people building agents, personal AI systems, coding assistants, or knowledge-base workflows! 😄

• What do you actually want long-term agent memory to remember?
• How should memory systems handle contradictions?
• Is human-editable memory important to you, or do you prefer invisible automation?
• Are curation levels and confidence/status metadata useful, or too much structure?
• What integrations would add additional value?

Repo/README: https://github.com/SweetSophia/noosphere/blob/master/README.md

https://preview.redd.it/4nhwu3kaan4h1.png?width=568&format=png&auto=webp&s=b0fd766d7d7386da575d7c92a229c2c5d030c3f8