Notes
A note is a short markdown file in the project's .dmn/memories folder. Agents write them as they learn something worth keeping: why a test is flaky, which file owns a setting, a decision you made. Every agent on the project can read them, whichever vendor it comes from.
---
name: stripe-webhook-raw-body
description: The Stripe webhook must read the raw body before any JSON parsing
---
Stripe signs the raw request body. The handler in app/api/stripe/route.ts reads
request.text() first; parsing JSON before verifying breaks the signature check.
Agents use dmn memory or the memory tool. You can read and edit the files like any others, or in the Memory view beside the Fleet panel.
Several agents can write the same folder at once, so DMN records in each note which agent wrote it, from which branch, and when. When an agent replaces a note another session wrote, the old text is kept in .dmn/memories-archive/history/ and the agent is told whose it was. When it starts a note that another one may already cover, it's told which, so it can update that one instead.
| Command | What it does |
|---|---|
dmn memory list |
The project's notes |
dmn memory read <path> |
One note |
dmn memory write <path> --content "<text>" |
Write a note, replacing any note at that path |
dmn memory delete <path> |
Move one to .dmn/memories-archive/ |
Notes sit alongside CLAUDE.md, AGENTS.md and Claude Code's auto memory rather than replacing them. Claude Code's memory between sessions compares them.
Your rules
A rule is a note in the rules/ folder, or one you mark with kind: rule in its front matter. Rules come first in every briefing, before any agent's notes, so use them for what every agent must know: how you want tests run, what never to touch.
Claude Code also saves your guidance in its own memory. The briefing lists the pieces no rule here says yet, marked as coming from Claude Code's memory, so agents from other vendors see them too.
---
name: no-force-push
description: Never force-push; open a new branch instead
kind: rule
---
The briefing
A session starts
- How to ask DMNsearch before grep, in a project DMN indexes
- Lessonserrors fixed in earlier sessions, with their fixes
- The projectits overview note, then your rules
- The newest noteseach with its age, flagged when the code it names has changed
- Who else is workingthe other agents on the project right now
- Short answersthe terse-answer rule, for Claude Code unless you turn it off
A session starts with a briefing built from the project's files. Claude Code gets it from the hook dmn hook-init installs, at the start of each session and again after it compacts its context. Codex gets it from its own hook, and agents connected over MCP get it with DMN's server instructions. A note whose code has been deleted, or changed in a commit since the note was written, is flagged, so an old note isn't taken for a current one.
Progress notes belong in status/: the briefing shows them for two days under "In flight", apart from what agents learned. When other agents are working on the same repository, in any of its worktrees, the briefing names each one with its branch, its task and what it last finished.
While a session runs, Claude Code is told before each prompt what other agents wrote since its last one, a new rule in full. A rule you give one agent reaches the others on their next turn.
Lessons
When agents in two or more sessions hit the same error and fix it the same way, DMN turns that into a lesson: the error, and a one-line fix. Lessons come from your Claude Code and Codex session logs, read on your machine with recognised secrets removed.
- The briefing lists them, so a new session knows them from the start.
- In Claude Code, when a command fails and matches a lesson, the hook hands the agent the fix straight away.
dmn gotchas listshows them, anddmn gotchas forget <id>stops one for good. The command line calls lessons gotchas.
Error fixes writes up lessons DMN learned in our own sessions, with the cause and the fix for each.
Past sessions
dmn memory search "<question>" searches dated records of earlier sessions: what each was asked, what it ran and what it concluded. Use it when you remember that something was done, but not where.
Claims
Before an agent edits, it can claim the files or folders it's about to change, with a reason and an expiry (30 minutes unless it asks for longer, up to eight hours). Other agents check claims before they edit, and see who holds a file and why.
Claims are advisory. They never block a write: they're there so parallel agents can see each other, not to lock anything. Agents use the lease tool for them, or dmn lease from a shell; you don't manage anything.
dmn lease claim src/billing --reason "moving retries into the client"
dmn lease check src/billing/client.ts # held by someone else?
dmn lease release # done: release all of yours
A claim belongs to the agent that made it. Agents in DMN's panes, Claude Code and Codex have an identity already; a shell without one can check and list claims, and dmn says what to set before it can hold one.