Memory

Memory is the instructions Command Code carries into every turn without you repeating them — conventions, architecture notes, the commands your project actually uses. It lives in plain markdown files named AGENTS.md.

Start here

Create one for your project:

That writes AGENTS.md in your project root with a starter template. Edit it like any file, or run /memory to pick which memory file to open.

Where memory files live

Command Code reads three tiers, and every one that exists is loaded — they add up, they don't replace each other.

They're assembled in that order — user, project, then subdirectory — each block headed by its source path, so the model always knows which file a rule came from. Later blocks are more specific, so a package-level convention naturally reads as a refinement of the project-level one.

Project memory

Both <project>/AGENTS.md and <project>/.commandcode/AGENTS.md are checked, in that order — the first one that exists is used, not both. Put it at the repo root if you want it visible; put it in .commandcode/ if you'd rather keep the root clean.

Subdirectory memory

Subdirectory memory loads on demand. When you @-mention a file (or the agent reads one you referenced), Command Code walks from that file's directory up to the project root and picks up any AGENTS.md it finds along the way, outermost first, so the nearest file has the last word.

Only directories inside your project count — a sibling tree that happens to share a path prefix is never pulled in.

Importing other files with @path

Any @path reference inside a memory file is replaced with that file's contents, so a memory file can compose rather than duplicate:

• Paths are relative to the file doing the importing; ~/ expands to your home directory; absolute paths work.
• Imports are recursive, up to 5 levels deep.
• Each expansion is wrapped with an # Imported from <path> header so the source stays visible.
• References inside code fences or backticks are left alone, so documenting @something doesn't accidentally import it.
• A path that doesn't resolve to a readable file is left as plain text rather than failing the turn.

How memory reaches the model

Memory is part of the system prompt, not the conversation. That has a few consequences worth knowing:

• It's re-read every request. Edit AGENTS.md mid-session and the next turn picks it up — no restart needed. /context flags the row as (modified, refreshes next request) until then.
• It survives compaction. Because it isn't conversation, it's never summarized away. See Context & Compaction.
• It costs tokens on every turn. /context shows exactly how many under the Memory row. A memory file that has grown into a wiki is a real, recurring cost — keep it to standing rules, and use @path imports for the long-form material so it's only there when it's relevant.

Reference

Commands

File paths

See also

• Taste — learned style, as opposed to written rules.
• Skills — instructions that load only when a task calls for them.
• Context & Compaction — what memory costs per request.
• Import — bring memory files from another agent.