Knownbase — Persistent Project Memory for AI Coding Agents

Persistent project memory for AI coding agents

Stop re-explaining your codebase to AI.

Knownbase gives your AI coding agents persistent, searchable project knowledge, so architecture decisions, debugging discoveries, conventions and lessons survive across sessions and tools.

Give your agents memory<br>See how it works

Works with Claude Code, Codex, Cursor, ChatGPT and any MCP-compatible agent. Free plan, no card required.

Why we dropped the queue-based importer decision · payments-api · still current

Flaky checkout test = timezone in parseDate debugging · payments-api · resolved

Prod Mongo has no Atlas Search — regex fallback only constraint · payments-api · load-bearing

"mcpServers": {<br>"knownbase": { "url": "https://knownbase.dev/mcp" }

Survives the session Knowledge lives outside the context window, so ending a conversation doesn't end what the project knows.

Shared across agents One workspace that Claude Code, Codex, Cursor and your teammates' agents all read and write.

Retrieved, not reloaded Agents search for the slice they need instead of loading an ever-growing instruction file every time.

The problem

Your AI is smart. Your project knowledge keeps disappearing.

None of these are model failures. They're storage failures: the agent learned something real and had nowhere durable to put it.

New session, same explanations Every fresh conversation starts by re-describing the architecture, the conventions and the constraints you explained yesterday.

Compaction loses the discoveries The context gets compacted mid-task and the hard-won finding from two hours ago is summarized down to nothing. What compaction actually drops →

Agents repeat solved problems The same bug gets re-diagnosed from scratch, and the same rejected approach gets proposed again next month. Why this keeps happening →

Claude and Codex don't share anything Whatever one agent figured out is invisible to the other, so switching tools means rebuilding context by hand. Share context between them →

Decisions vanish into old chats The reasoning behind a schema, a library choice or a rejected design is buried in a conversation nobody can search.

The instruction file keeps growing CLAUDE.md creeps toward a thousand lines because it's the only place knowledge can go. Instructions vs memory →

The outcome

Project knowledge that survives the conversation.

An agent writes what it learned. Every later agent — yours, a different tool, a teammate's — can search for it.

Agent at work Makes a decision, corners a bug, hits a constraint.

Knownbase Stores it as a versioned, searchable, project-scoped note.

Searchable project memory Organised by project, tag and status. Linkable and revisioned.

The next agent Retrieves exactly the relevant slice and continues.

What agents store

Git remembers what changed. Knownbase remembers why.

Version control is a perfect record of every diff and a terrible record of the reasoning behind it. The reasoning is what an agent needs and what git was never designed to hold.

Architecture decisions<br>Why this library, this schema, this trade-off — captured once so no agent relitigates it three months later.

Debugging discoveries<br>The investigation that finally explained a flaky test, so the cause survives past the session that found it.

Rejected approaches<br>What you already tried and why it failed. The single highest-value thing to store, and the one nothing else records.

Operational constraints<br>The deployment landmines, rate limits and environment quirks that only reveal themselves in production.

Project conventions<br>How this codebase does errors, naming, tests and migrations — the local dialect an agent has to match.

Session handoffs<br>What's done, what's in progress, and the one next step, ready for the next agent. How to write one →

Differentiation

Instructions aren't the same as memory.

CLAUDE.md and AGENTS.md are good at what they do. They're just solving a different problem, and using one for the other is why instruction files end up unmaintainable.

CLAUDE.md / AGENTS.mdKnownbase

What it holdsStanding instructions: how to behave in this repo.Accumulated knowledge: what has been learned about this project.<br>How it's loadedEntirely, into every single session.Searched on demand; only the relevant slice enters the context.<br>How it scalesStays useful while it stays short. Costs context on every turn as it grows.Grows without bound. Retrieval cost doesn't grow with the store.<br>Who writes itYou, by hand, in a text editor.The agent, as it works, over MCP.<br>HistoryWhatever git shows for the file.Per-note revisions, with links between related notes.<br>ReachOne repo, one tool's conventions.One workspace, every MCP client and teammate.

Keep the instruction file for rules. Move the growing pile of decisions and discoveries into project memory. The full comparison, with a worked example →

Multi-agent

Switch agents, not context.

Project memory that...