The engine your agents ask instead of grepping
A local engine indexes your code and keeps the index current as files change. Agents ask it through a command line, an agent skill or MCP, and get back the exact code they need instead of reading file after file. It also keeps the notes they share and the files they've claimed.
Your agent goes straight to the code
Asked where logins are rate-limited, Claude Code found tooManyAttempts either way. On its own it searched, then opened a file to read the code. With DMN the search brought the code back, so it answered a round trip sooner.
Real runs: Claude Code (Sonnet) on a 44-file sample project, three times without DMN and three times with DMN as it ships, terse answers on. Each pane replays one run; the figures are the medians. The runs.
2 instead of 3
requests to the model
DMN's search brought the code back, so the agent didn't open files to read it.
2.2 s
sooner to the answer
6.2 s without DMN, 3.9 s with it: the median time from the question to the answer.
20 ms
for DMN to answer
It has already read your code, so it answers from its index. CPU only, on the sample project.
On real bug reports
On this small project DMN used a few more tokens: 16.5k without DMN, 17.3k with it. Its terse-answer rule adds about 800 tokens to every request, and a two-request lookup is too short to win that back. On real bug reports in larger codebases, agents found the code in 21–25% fewer round trips and 16–22% fewer tokens, and found the right code about as often, so your usage limits go a bit further. With terse answers on, our latest benchmark, on DMN's own code, used 35% fewer tokens than no DMN. A whole coding session also writes and tests code, so it saves less. How we measured.
How fast it is
Speed shows up in three places: how fast DMN answers, how soon it knows about an edit, and how many round trips your agent doesn't have to make.
5–12 ms
to answer a search
Median over 17 developer questions each on Django, Vite and ruff, on a desktop with a GPU. On the CPU alone, about 20 ms on the sample project above.
2.2 s
from saving a file to finding it
Median over 24 saves on the sample project, CPU only, and 2.3 s to be found by meaning. Two seconds of that is a set pause that gathers a burst of saves into one update. The update itself took about 0.15 s.
21–25%
fewer round trips to find the code
Every round trip your agent skips is one less request to its model: about 3 seconds plus the time to write its reply, in our measured runs.
Not measured yet: a whole coding task from start to finish. Looking through code was about a fifth of a task in our runs, so the gain there is smaller. How we measured speed.
How it finds code
DMN indexes your project three ways, on your machine. When an agent asks, it searches the ways that fit the question, merges the results into one ranked list, and sends back the code itself.
Your project
- app/login/actions.ts
- app/signup/actions.ts
- lib/auth/password.ts
- lib/supabase/middleware.ts
- lib/stripe.ts
- lib/auth/throttle.ts saved, indexed again
- + 38 more files
The index, three ways
Meaning
"rate limit logins" ≈ tooManyAttempts
A small model on your machine matches what code does, not just what it's called. It found this one.
Words
rate limit logins no match
Keyword search (BM25) catches exact names. Here it has the same problem as grep.
Structure
Every symbol and its calls. It answers the next question: who calls tooManyAttempts?
Your agent
> where do we rate-limit logins?
grep -ri "rate limit" 0 files
dmn search "rate limit logins" --curate
- lib/auth/throttle.ts:9-38 export function tooManyAttempts(ip: string): boolean {
- app/login/actions.ts:1-22 export async function login(_prev: LoginState, formData…
- lib/supabase/middleware.ts:6-43 export async function updateSession(request: NextRequest) {
- app/signup/actions.ts:1-16 if (tooManyAttempts(ip)) {
- + 6 more sections, fitted to a token budget
One call, about 20 ms on a CPU. The code the question meant, and the code that uses it.
$ dmn search "rate limit logins" --curate 10 section(s) for "rate limit logins" ── lib/auth/throttle.ts:9-38 ── const MAX_FAILURES = 5; … /** True when this IP has failed too often recently and must wait. */ export function tooManyAttempts(ip: string): boolean { return recent(ip, Date.now()).length >= MAX_FAILURES; } … ── app/login/actions.ts:1-22 ── … export async function login(_prev: LoginState, formData: FormData): Promise<LoginState> { const ip = await clientIp(); ── lib/supabase/middleware.ts:6-43 ── …
Ask about structure, too
dmn search "<question>" --curate # ranked code, fitted to a budget
dmn context tooManyAttempts # definition, callers and impact
dmn search --mode trace tooManyAttempts # who calls it
dmn impact --symbol tooManyAttempts # what a change could break
dmn grep "exact text" # exact matches, with context41 languages are parsed into the graph. The index updates as files change, and in Claude Code a hook re-indexes each file an agent edits straight away.
Notes every agent shares
Agents save what they learn as short notes in your project, in .dmn/memories. Every agent on
the project can read them, whichever vendor it comes from, and a new session can start from what earlier
ones found.
In the demo, Codex asks about Stripe and gets back a note Claude Code saved two days earlier: the webhook must read the raw request body. So it adds checkout without breaking the webhook.
A new session starts with your rules first, then the newest notes, each with its age. A note whose code has changed since it was written is marked, so an old note isn't taken for a current one.
DMN also learns from past sessions on its own. When an error that earlier sessions fixed turns up again, Claude Code is told the fix in one line, and any agent can search what earlier sessions were asked, ran and concluded.
Agents read and write notes with dmn memory or the memory MCP tool, and search past
sessions with dmn memory search. In Claude Code, dmn hook-init briefs each new
session.
Agents see who's editing what
Before an agent edits, it claims the files or folders it's about to change. Another agent checks before touching a path, sees who holds it, and works around it.
- Claims are advisory: they never block a write.
- They expire on their own, and end when the agent's connection closes.
- Agents use the
leasetool; you don't manage anything.
Want full isolation instead? The spawn sheet can start an agent in its own git worktree and branch.
pricing lease claim components/Pricing.tsx ✓ claimed checkout lease check components/Pricing.tsx held by pricing · expires on its own checkout edit app/api/checkout/route.ts +12 lines pricing done Pricing.tsx is free again
Works with the agents you use
Start them in DMN's panes, or give the agents you run elsewhere DMN's search and notes. The app can set this up for you. From a terminal, it's one command.
-
Claude Code
- Pane
- Chat pane
- Skill
- MCP
- Edit hook
-
Codex
- Pane
- Skill
- MCP
-
Gemini CLI
- Pane
- Skill
- MCP
-
Cursor
- Pane
- Skill
- MCP
-
OpenCode
- Skill
-
Aider
- Pane
-
Continue
- MCP
-
Warp
- MCP
-
Any MCP client
- MCP
- Pane
- Start it from "+ agent" in DMN, beside your other agents.
- Chat pane
- Claude Code in DMN's chat view instead of its terminal.
- Skill
- Teaches the agent the
dmncommand line. - MCP
- Adds DMN's MCP server, with the tools listed below.
- Edit hook
- Re-indexes each file the agent edits, straight away.
Add the skill
For Claude Code, Codex, Gemini CLI and Cursor. OpenCode reads the same skill folders. It costs one line of context until it's used.
dmn skill-init --apply
Add the MCP server
Adds DMN's MCP server to every client it finds.
dmn mcp-init --apply
Leave out --apply to preview what either command would change. dmn config verify
checks the wiring, and dmn doctor checks everything else.
The MCP tools
| Tool | What it does |
|---|---|
search | Code search: meaning, words and structure, plus symbol, caller, file and exact-text modes |
read | Read source by path or symbol, or the project's rules |
memory | The project's shared notes: read, write, delete |
impact | What a change to a symbol or file could break |
lease | Claim paths before editing, and check others' claims |
repo | Branch, status, recent commits and stashes, in one read-only call |
test | Which tests a change affects |
index | Index status and control |
edit, run | Edit a file or run a command, each approved through your client |
canvas | Show diffs, files and test results in the workspace |
It runs on your machine
- The engine only listens on your own machine (127.0.0.1).
- Embeddings come from a bundled model, run on your GPU (CUDA or DirectML) or your CPU.
- You can point it at a remote embedding service if you want one. It's off unless you set it up.
- Your agents keep talking to their own providers, as they do without DMN.
See what it saved you
dmn stats reports how many fewer tokens of code DMN handed your agents than reading the same
files whole, per agent and per day. The app's Insights view shows the same numbers.
That comparison is with reading whole files, so it runs higher than the head-to-head numbers on the benchmarks page.