The DMN engine: code search, memory and file claims for agents

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.

A real run on a 44-file sample project: the code never says "rate limit", so a grep for those words finds nothing and keyword search has nothing to hold on to. Each hit is a whole section; one line of each is shown. How we measured.

dmn search · sample project · real output, trimmed

$ 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 context

41 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 lease tool; you don't manage anything.

Want full isolation instead? The spawn sheet can start an agent in its own git worktree and branch.

claims · illustration

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 dmn command 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.

The engine your agents ask instead of grepping

Your agent goes straight to the code

On real bug reports

How fast it is

How it finds code

Ask about structure, too

Notes every agent shares

Agents see who's editing what

Works with the agents you use

Claude Code

Codex

Gemini CLI

Cursor

OpenCode

Aider

Continue

Warp

Any MCP client

Add the skill

Add the MCP server

The MCP tools

It runs on your machine

See what it saved you

Connect your agents