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.
Works with Claude Code, Codex, Cursor, ChatGPT and any MCP-compatible agent. Free plan, no card required.
Why we dropped the queue-based importerdecision · payments-api · still current
Flaky checkout test = timezone in parseDatedebugging · payments-api · resolved
Prod Mongo has no Atlas Search, regex fallback onlyconstraint · payments-api · load-bearing
{
"mcpServers": {
"knownbase": { "url": "https://knownbase.dev/mcp" }
}
}
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 explanationsEvery fresh conversation starts by re-describing the architecture, the conventions and the constraints you explained yesterday.
Compaction loses the discoveriesThe 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 problemsThe 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 anythingWhatever 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 chatsThe reasoning behind a schema, a library choice or a rejected design is buried in a conversation nobody can search.
The instruction file keeps growingCLAUDE.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 workMakes a decision, corners a bug, hits a constraint.
KnownbaseStores it as a versioned, searchable, project-scoped note.
Searchable project memoryOrganised by project, tag and status. Linkable and revisioned.
The next agentRetrieves 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
Why this library, this schema, this trade-off, captured once so no agent relitigates it three months later.
Debugging discoveries
The investigation that finally explained a flaky test, so the cause survives past the session that found it.
Rejected approaches
What you already tried and why it failed. The single highest-value thing to store, and the one nothing else records.
Operational constraints
The deployment landmines, rate limits and environment quirks that only reveal themselves in production.
Project conventions
How this codebase does errors, naming, tests and migrations: the local dialect an agent has to match.
Session handoffs
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.md | Knownbase | |
|---|---|---|
| What it holds | Standing instructions: how to behave in this repo. | Accumulated knowledge: what has been learned about this project. |
| How it's loaded | Entirely, into every single session. | Searched on demand; only the relevant slice enters the context. |
| How it scales | Stays useful while it stays short. Costs context on every turn as it grows. | Grows without bound. Retrieval cost doesn't grow with the store. |
| Who writes it | You, by hand, in a text editor. | The agent, as it works, over MCP. |
| History | Whatever git shows for the file. | Per-note revisions, with links between related notes. |
| Reach | One 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 belongs to the project rather than to whichever tool happened to be open when the knowledge was created.
Claude CodeFinds the real cause of a production incident and writes it down.
One shared workspaceProject-scoped, searchable, versioned. Reachable over MCP from anywhere.
Codex · Cursor · ChatGPTRetrieve that finding on a later task without you re-typing a word of it.
Claude Code
One command to connect, OAuth sign-in, no key to paste. Set up Claude Code →
Codex
Same endpoint, same workspace, same notes. Set up Codex →
Cursor
Add one entry to mcp.json and Cursor gains project memory. Set up Cursor →
Production-verified continuity
One agent stops. The next one keeps going.
This recommended operating loop is backed by a live two-session resume check. Session B received only a project name and saved cursor — no pasted summary and no hidden chat history.
get_context({ project })
Loads the current decisions, constraints, state and open work before touching code.
remember({ type: "decision", content })
Stores what was learned while reporting duplicates or conflicts instead of silently adding another claim.
checkpoint({ summary, openItems, nextActions })
Closes the session as structured, versioned project memory — not a raw transcript.
6 durable memories
Knownbase
one saved cursor
get_context({ project })
Reconstructs what is true now. Superseded and historical claims stay out of the authoritative view.
get_changes_since({ cursor })
Returns each source-backed change once, with note IDs and bounded excerpts for exact follow-up.
checkpoint({ resolvedItems: [noteId] })
Resolves the inherited task without deleting its history; an old retry cannot reopen it.
The result metrics come from the live resume and retry checks; the cards show the recommended full workflow. Verified against knownbase.dev on August 21, 2026. Humans can inspect, correct, version and audit every memory in the dashboard.
Enable JavaScript to play the walkthrough; the verified result remains available above.
How it works
Three steps from cold start to safe continuation.
No SDK, no vector database to run, no repo changes. The differentiated workflow is already built into the MCP instructions your agent receives.
Point any MCP client at https://knownbase.dev/mcp. get_context returns the current project state in one bounded call. Setup instructions →
remember stores a decision or discovery with duplicate/conflict feedback. checkpoint folds the session's durable state without uploading its transcript.
The next agent loads current memory and follows its saved get_changes_since cursor. Humans inspect, correct and audit the same notes in the dashboard.
Affordable plans
Start free, upgrade when your agents need more memory.
Every paid plan starts with a 7-day free trial. No charge until it ends, cancel anytime.
FAQ
The questions developers actually ask first
Why does my AI coding agent forget my project between sessions?
Because a context window is working memory, not storage. Everything an agent learned during a session — why you rejected an approach, what actually caused a bug, which deployment constraint bit you — lives in that conversation and disappears when the session ends or the context is compacted. Knownbase keeps that knowledge outside the context window, in a store the next session can search.
Isn't that what CLAUDE.md or AGENTS.md is for?
Those files are instructions: a small, hand-maintained set of rules loaded into every session. Knownbase is accumulated knowledge: hundreds of decisions, debugging trails and constraints that an agent retrieves only the relevant slice of. Instruction files stay small and get loaded every time; project memory grows without end and gets searched on demand. Most teams want both.
Which agents and tools work with Knownbase?
Anything that speaks the Model Context Protocol: Claude Code, Claude Desktop, ChatGPT, Codex, Cursor, and local agents. Point the client at https://knownbase.dev/mcp and sign in with OAuth, or paste an API key. Agents load current state with get_context, store durable knowledge with remember, close work with checkpoint, and resume incrementally with get_changes_since.
Can two different agents share the same project memory?
Yes — that is the point. A workspace is a shared store, so a discovery Claude Code writes today is retrievable by Codex, Cursor or a teammate's agent tomorrow. You switch agents without rebuilding context.
Is my project data isolated and secure?
Every note is scoped to your workspace and never shared across tenants. Sessions and API keys are stored hashed, passwords use PBKDF2, and keys can be made read-only or restricted to a single project. Your content is never used to train models. You can export or delete everything at any time. Read the full security and data-ownership page.
Can I start for free?
Yes. The Free plan includes 3 projects, 300 notes, and 2 MCP keys, with no card required. Paid plans each start with a 7-day free trial.
From the blog
How persistent agent memory actually works.
Claude Code keeps forgetting your project?
Why it happens, what CLAUDE.md and auto-memory each cover, and how to add persistent memory.
Context compaction: what gets lost
What a compaction pass actually drops, and how to make the important findings survive it.
MCP memory servers explained
What an MCP memory server is, the kinds that exist, and which one fits which problem.
Featured on
Find Knownbase across the startup community.
