Your AI writes the code.
Kodela remembers why.
Give your AI agent permanent memory of this repo in one command. Kodela captures the reasoning behind every change and keeps a live Memory Bank your agents read — so intent survives long after the session ends.
$ npx -y @kodela/cli connect --apply --npxOne command wires Kodela into every AI tool it detects — Claude Code, Cursor, VS Code and more — and generates your Memory Bank.
Code written by AI leaves a trail. The reasoning behind it evaporates.
Commit messages and comments don't capture why a change was made, what alternatives were rejected, or which AI made which decision. The moment a session ends, that intent is gone — and the next engineer, or the next agent, starts from zero.
As more of your codebase is authored by AI, the gap compounds. Kodela closes it: structured, queryable, enforced context that lives alongside the code itself.
Without Kodela
git blame shows who and what. The why lives in a chat log that's already been deleted.
With Kodela
Every change carries its actor, the problem it solved, the alternatives considered, and a risk rating — queryable by humans and agents alike.
Not another AI coding assistant.
AI Context Infrastructure.
Assistants generate code. Kodela governs the knowledge that code generation produces — a foundational layer beneath every AI tool your team already uses.
Assistants write
Kodela remembers
Tools like Claude Code and Cursor produce changes. Kodela preserves the intent behind them.
Diffs show what
Kodela shows why
A queryable memory graph of decisions, problems solved, and rejected alternatives.
Per-tool silos
One shared memory
Capture is tool-agnostic, so context survives across agents, repos, and sessions.
One command. Your AI remembers the whole repo.
No setup, no account, no flags to memorize. Connect once and the memory builds itself — then browse it in a free local app, hand it to any model as one file, or paste it into a PR.
kodela uiBrowse it — free local app
Not CLI-only. One command opens an interactive local web app: search the why, filter by severity, drill into any file, explore the co-change graph, read decisions, browse the timeline, and watch your memory compound. No account, nothing leaves your machine.
kodela connectAuto Memory Bank
Generates the six markdown files agents already read at the start of every task — and the watcher keeps them current. The standard Memory Bank, maintained for you.
kodela packYour repo + its why, in one file
Packs the repo map, project DNA, and the captured reasoning into a single AI-ready file you paste into any model. Works on the first run, before any context exists.
kodela explain --shareShareable why-this-changed
Turns a file's captured context into a clean markdown snippet for a PR description or a handoff — the reasoning, not just the diff.
Everything an AI-native codebase needs to stay legible
One memory layer, captured automatically, surfaced to the humans and agents who need it.
AI Context Engine
Structured capture of actor, problem, reasoning, and rejected alternatives for every change — not free-text notes.
Knowledge Graph
Explore your codebase as a network of decisions and relationships. Ask why any file is the way it is.
Timeline & Evolution
Replay how a module, decision, or architecture evolved — and which AI tool drove each step.
Decision Tracking
Human-authored decisions are first-class records, linked to the code and context they govern.
Cross-Repository Memory
Context isn't trapped in one repo. Shared architecture memory follows your platform across services.
AI Governance
Drift detection, risk ratings, and sign-off gates keep AI-authored changes accountable and reviewable.
Two capture paths. One memory.
When an agent can drive the protocol, it authors the why in its own words. When it can't, a ground-truth watcher records the what — so nothing slips through.
MCP-capable agents
Claude Code · Cursor · MCP clients
Silent-capture watcher
git + filesystem · 6-layer attribution
One memory
Queryable. Enforced. Shared.
MCP fast path
MCP-capable agents call Kodela directly to record sessions, annotations, and decisions — the highest-fidelity capture.
Silent-capture watcher
For everything else, a watcher observes git + filesystem changes and attributes them — guaranteed coverage.
Enforced at close
A session can't end until every touched file is explained, checked against a git-diff baseline.
Works with the AI tools you already use
Kodela sits beneath your stack, not in front of it. Tool-agnostic capture means context is consistent no matter who — or what — wrote the code.
Start solo and local. Go multiplayer when the why needs to be shared.
Kodela starts as your private, local memory — free forever, Apache-2.0. The moment someone else needs to see the why — a reviewer, a new hire, your whole team — that's the upgrade: one shared memory with roles, review, and governance. We never paywall the fundamentals.
Community
Your private memory, on your machine. Browse it in the free local app. Apache-2.0.
Team
The day a teammate asks “why is this like this?” — one shared org memory you can Ask in plain language, with roles, change review, and drift sign-off.
Cloud
The team dashboard, hosted and operated for you — zero ops, automatic upgrades, usage analytics, and SLA-backed availability.
Enterprise
Governance at scale: SSO, RBAC, audit, air-gap, and private-LLM governance.
Give your codebase a memory.
Install the open-source core in under five minutes. No account required for local single-developer use.