Coding agents that know your code — and remember your team's corrections
Kurtel maps your repository locally and gives Claude Code or Codex only the files, dependencies and team rules the current task touches. Fewer searches, fewer turns, fewer repeated mistakes.
Claude Code · Sonnet 5 · ~/shopClaude Code · Sonnet 5 · ~/shopTrusted by
Supported by the startup programs at Anthropic, Microsoft, Vercel, Supabase.
Less context burned. Fewer turns. An hour a week back, per developer.
Compact context instead of whole-directory dumps.
7.2 → 4.2 turns. Less blind exploration per task.
Tasks land faster, with less rework and shorter PR reviews.
Median across pilot repositories, measured before and after on the same tasks. As a design partner, you get the same figures for your codebase — see how to start.
Your agent starts every task like a new hire.
It writes code fast. But it does not know your codebase, and it does not remember what your team told it.
It is amnesiac
Last week someone corrected it: amounts go through the money helper, never floats. Next session, on another developer's machine, it makes the same mistake — and someone corrects it again. Nothing your team teaches it is kept.
It doesn't know your codebase
Every task starts with the agent rediscovering your repository file by file — the bigger the codebase, the more it rebuilds and the more it misses what a change will break. Worse, some architectural decisions are simply not in the code at all.
It can't tell which context matters
So it piles up everything it reads and everything it is given — CLAUDE.md, skills, whole files — relevant or not. More context is not free: even on the same task, Claude Opus 4.5 falls from 96% to 15% accuracy as its context grows from 8K to 256K tokens. (LOCA-bench, 2026)
Give the agent what your best developers already know.
Kurtel doesn't change the model. It changes what the model knows when it starts a task: your codebase, your team's rules, and only the part that matters.
It never makes the same mistake twice
When the agent makes a mistake and someone corrects it, Kurtel learns from it — and when a task succeeds, it remembers what worked. The next agent that touches that code, on anyone's machine, already knows. One developer's experience benefits everyone.
How it learnsIt knows your codebase from the first prompt
Kurtel keeps a map of your code — what calls what, what a change reaches — built on your machine and updated as you work. The agent starts where your best developer would, and it scales as the repository grows.
The code mapIt gets only what the task needs
For each task, Kurtel picks the few files and rules that apply — in milliseconds — and sends nothing when nothing does. Less context, chosen well: fewer tokens, fewer turns, and an agent that gets there faster.
The context engineCorrect the agent once. Every agent on the team knows — and can tell you why.
Corrections your developers already make — and the approaches that made a task succeed — become the team's memory: delivered where they apply, and traceable to the person who made them. A wrong correction does not spread silently: every rule shows who it came from, can be contested by anyone, and stops being sent once it stops helping.
Alice corrects her agent
“Amounts go through lib/money.ts, never floats.” One sentence, in the middle of a normal session.
Kurtel remembers it
For Alice, and for the whole team. It keeps who said it, when, on which code, and why.
Bob's agent already knows
About to edit the billing service, it receives the rule before it writes. Nobody has to repeat it.
“Why did you do it this way?”
The agent answers with the source: Alice's correction, the date, the task it came from. Like asking the colleague who made the call.
A skill file only grows. Kurtel's memory keeps what is still true and useful — and remembers the rest.
When someone contradicts a rule, it is flagged as contested — never silently overwritten. The correction that replaces it keeps its own source.
Rules that keep being useful stay; rules that stop helping step aside, so they do not crowd the agent's context.
Nothing is erased. Every version is kept: you can see what the memory said last month, who changed it, and why.
A map of your code, computed — not written.
Files, functions, imports, calls and routes, extracted from the code itself. Nobody has to write it or keep it up to date: it is refreshed as the code changes, and it scales to thousands of files where a hand-written file cannot.
Deterministic and local
Structure is extracted by AST analysis on your machine. Same input, same map, no model call.
Current with your branch
The graph is refreshed after changes and branch switches, so context reflects the code as it is now.
Blast radius
The reverse call graph shows what a change reaches, before the agent touches it.
Out of everything your team knows, the few things this task needs.
Kurtel builds each context from two sources: the code map, and your team's memory. The map is exact. The memory is where the hard choice is made — out of hundreds of rules and lessons, only a handful should reach the agent. Here is how it chooses.
“Context is a finite resource with diminishing returns, and irrelevant content degrades model focus.”
Anchor on the code
Kurtel finds the code the task touches, then gathers the memories that apply to it — whether they cover that one file, a whole module or the entire codebase.
Match the task
Kurtel then keeps only what relates to what you asked, with semantic understanding of the request — so a rule on refunds surfaces even if you called it a reimbursement.
Make sure it still applies
Code and decisions move on. When the team has since decided otherwise, or the code a memory describes has been rewritten, Kurtel holds it back rather than send yesterday's rule.
Keep what earns its place
Our own Bayesian scorer weighs every remaining memory and sends only the few that are worth the agent's attention for this task.
- src/services/orders.ts — the code to change
- 2 files that call it
- the route it serves
- Amounts in cents via lib/money.ts — Alice, Sept 12
- Lesson: refunds must emit an audit event
- ~150 tokens, not the whole repository
- With the prompt, and again right before an edit
- Nothing at all when nothing applies
Selection runs in milliseconds and involves no AI model: it is deterministic, and every choice can be explained.
Nothing changes in how your team works.
No new software to learn and no learning curve. Your developers keep working the way they do today — the only difference is that their agents actually learn, and get to the result faster and with fewer tokens.
Install it in minutes
One command per repository. Kurtel plugs into Claude Code or Codex and maps your code on the spot.
Work exactly as before
Developers do their tasks with their agent, just as they do today. Kurtel runs entirely in the background: no extra command to run, no dashboard to open — nothing else.
Your agents get better
Each correction your team makes, and each approach that worked, is remembered and shared. The agent reaches the right result faster, with fewer tokens.
Challenge past decisions
Before a refactor, trace the chain of decisions that led to the current code — who decided what, and why — and challenge the ones that no longer hold.
More memory is not the answer. The right memory is.
Teams usually try one of these approaches. Each helps a little; none of them knows your code, learns from your whole team and sends only what the task needs.
Your repository is never uploaded.
Kurtel works from a map of your code and the memory of your team — never from your files' contents. Here is exactly what is kept, and where.
What stays on your machine
- Your source code
- Full agent sessions, as captured
- The local copy of the map and the memory
What Kurtel stores
- The code map: file paths, function names, imports, calls and routes — never file contents
- Your team's memory: rules and lessons, who they came from, when, and which code they apply to
- Usage signals: which memories were used, and whether the task succeeded
What's never stored
- The contents of your files
- Anything from a repository you have not activated
What a session excerpt contains
- + Your prompts and the agent's final replies
- + Which tool the agent used, on which file path, and the commands it ran
- + The output of shell commands — tests, builds
- − Never the contents of the files the agent read or edited
- − Keys, tokens and passwords masked before anything is sent
- − Each item capped in length
Sent in small batches to the rule-extraction engine — ours, or yours on-premise — then discarded once rules are extracted.
Your agent's model provider still receives what your agent sends it today, plus the short context Kurtel adds.
Become a design partner.
Built for tech startups with a real, growing codebase. Kurtel is early: we work closely with a small group of teams — we set it up on your repositories, measure the difference on your real tasks, and build what you need next.
Cloud
Kurtel hosts everything.
- Team memory, context engine and code map hosted by Kurtel
- Nothing to install on your servers, nothing to operate
- Your source code still never leaves your developers' machines
On-premise
Everything runs in your infrastructure.
- Backend, context engine and storage deployed on your servers
- Inside your network policies, with the models you allow
- Nothing ever reaches Kurtel's servers