One memory layer for
AI-native engineering
Kodela captures the knowledge AI development produces and makes it useful — to the people reviewing the code, and to the next agent that touches it.
See how each capability works
Six capabilities, one engine. Capture is automatic — select any capability to see the mechanism behind it.
Each change is captured as a structured record — actor, problem, reasoning, and risk — instead of a free-text note. Watch a raw diff become a queryable fact.
Context that's a record, not a note
Each annotation is schema-validated and enforced at session close — so the data stays trustworthy enough to build on.
Prompt & decision history
The prompts, reasoning, and decisions behind a change, retained and searchable.
Ask-why retrieval
Agents call get_context before editing a file to learn why it's written the way it is.
Memory Bank & one-file pack
Auto-generated Memory Bank agents read at task start, and a single AI-ready file packing the repo and its captured why — one command, no setup.
Function → decision traversal
Ask why a specific function exists and trace it across the fused graph to the session that wrote it, the decision it implements, and the PR or incident behind it — one query, exposed to agents over MCP. The radial memory map links files three ways: co-change (moved together), real imports (one file requires another), and the decision each implements — so you see the wiring and the why, not just co-occurrence.
Shared org memory & Ask Kodela
In Team and Enterprise, each repo syncs its captured why — entries, the fused graph, and decisions — into one Postgres-backed org memory automatically. Reading is one-click and install-free: point any MCP client (Claude, Cursor, VS Code) at the hosted gateway URL, log in with OAuth, and get tools scoped to only your org's projects. Capture stays local and automatic; anyone can Ask Kodela in plain language, or an agent calls get_why, and everyone gets the same answer.
Comprehension & guided tours
A file → class → function map with plain-English descriptions, each node fused with the captured why — and dependency-ordered onboarding tours that weave the decisions and risk into every stop. Localized, offline, in the CLI.
Change impact, both axes
The blast radius of a change: the files that transitively import what you touched, fused with the decisions and risk in that radius. A --ci gate stops a commit that reaches load-bearing code before you've read the why.
Architecture map
Auto-derived technical layers and business domains, the risk each carries, and the cross-layer dependency matrix — refinable per repo. See where the risk concentrates and where layering is violated.
Capture that fits your flow
Choose how strictly context is captured: enforced (every change explained), assisted, or ambient — install, keep working, and let missing context fill in asynchronously.
Plugin platform
Extend capture and retrieval — CLI, VS Code, MCP, CI, and your own integrations.
{
"file": "src/auth/session.ts",
"actor": { "source": "ai", "tool": "claude-code" },
"problem": "Old refresh token stayed valid after rotation.",
"why": "Session manager owns currentTokenId; rotation must
write the new id so the next refresh can verify it.",
"alternatives": ["share id in Redis (rejected: already replicated)"],
"risk": "medium",
"links": ["src/auth/jwt.ts", "src/auth/middleware.ts"]
}Not a general memory framework. A code-aware memory layer.
Frameworks like Cognee and Mem0 give agents a general memory of conversations and facts. Kodela is built for the codebase: it captures the reasoning behind code changes, linked to the code itself — and sits beneath the agents you already use.
General AI-memory frameworks
e.g. Cognee, Mem0
- •Store chat turns and facts as embeddings in a vector DB
- •Application-level memory — not aware of your code's structure
- •Usually cloud-hosted; your data leaves the machine
- •A framework you build your agent on top of
Kodela
The why behind code changes
- ✓Code-aware: fuses the AST + imports with decisions, risk, and actor
- ✓Captures the why of each change, in the dev loop — not chat history
- ✓Local-first and offline by default; no account, nothing leaves your machine
- ✓Sits beneath Claude Code, Cursor, Cline — a layer, not a competing agent
Understand any codebase — structure fused with the why
A comprehension map, dependency-ordered onboarding tours, change blast-radius, and an auto-derived architecture map — every node carrying not just what the code is, but the recorded why. All offline in the community CLI; interactive in the dashboard.
The team dashboard
Team, Cloud, and Enterprise editions add a shared web dashboard over the same captured memory — intelligence, the fused knowledge graph, governance, and org administration, plus Ask Kodela: pick a repo's shared memory and ask in plain language, the same answer every agent's get_why sees. A walkthrough of every view:
See the why behind every change
Install the open-source core and start capturing context in minutes.