Print the card below and nothing else. Change no state, start no work.

Print it in the language the user writes in. Translate the prose, leave every command, dial name, filename and number exactly as written — those are typed, not read.

The worth knowing column is the only place for anything beyond what a thing does. If a row has nothing surprising to say, leave it empty rather than filling it.

ATLAS

Four dials, eleven commands, five subagents.

It ships off. A fresh install changes nothing until you type atlas low or atlas high. After that the setting persists — across turns and restarts — until you change it or type atlas off, which persists too. It is one setting per project (the folder the session runs in, walked up to the nearest .git or .atlas.json), not a per-chat one and not a global one: a repository never switched on stays off whatever another one is set to.

Uninstalling does not reset it: the states live in ~/.claude/atlas-state/, one file per project, outside the plugin. atlas off in the project before uninstalling, or delete that folder.

Dials

In visible tokens, every combination costs less than no plugin at 295 turns; at 40 turns low + ask + check is +1%. Billed output, thinking included, is another matter: low +2% English and +5% Italian, high -25% and -18%. The two figures are a short session — 40 turns, 500-token answers — and a long one at 295 turns: the fixed cost is paid once and then spreads, so session length moves the number more than the dials do.

Never compressed at any level: code blocks, error strings, function and command names, file paths, numbers and units, negations, proper names, qualifiers that change what is true. Security warnings and irreversible-action confirmations are written in plain prose.

Commands

Typed, by name: atlas recap, or /atlas-mem:atlas-recap. Only the description is always loaded; the body costs nothing on sessions where you never call it (bodies: tiktoken cl100k). Asked in plain words without the name, the work is usually done without the command's rules.

Memory section — atlas-mem and atlas-max

Two more commands, atlas memory and atlas artifact, and the tools they drive. The memory is the markdown vault the project already keeps, one file per fact; nothing is captured automatically. What this build adds is the part a vault cannot do by itself: notice when a note has gone stale.

The tool, tools/memcheck.mjs, does everything that needs a hash or a comparison: a model cannot compute a fingerprint in its head. It parses the code with tree-sitter (grammars shipped in tools/wasm/: JavaScript, TypeScript, TSX, Python, Go, Rust, Java, C#, C/C++, Ruby, PHP, Bash, PowerShell) and falls back to a line-shape search for anything else. Its data lives in one sidecar file beside the notes, <vault>/.atlas/links.json; the notes themselves stay plain markdown in the format of whatever already manages them. memcheck impact says which notes a change to a file would touch, before the change.

A second tool, tools/codegraph.mjs, draws the code graph across projects: one root folder, one project per sub-folder, every source file parsed once. It records files and imports, top-level symbols and who calls whom inside a project, code written twice (identical text, or the same shape under other names) inside and across projects, and the symbols nothing calls, graded against the list of what a static graph cannot see (dynamic dispatch, IPC by string, FFI, entry points). scan, report, dups, hubs, dead. Pairs of projects declared as a porting are marked and never counted. It writes one JSON and never touches a source file; "uncalled" is a label, never a removal.

A third tool, tools/harvest.mjs, feeds the memory from what already exists without ever writing a note by itself: it pulls the decision-shaped lines out of past Claude Code sessions and project documents (extract, docs), takes the candidates a model proposed from them (inbox write) and keeps them in <vault>/.atlas/inbox/ until a person accepts or rejects each one (inbox accept, inbox reject). harvest suggest has a model propose accept / merge / reject for each candidate with the reason, shown beside it; the person still decides. A rejected candidate is never proposed again; a candidate that says what the vault already says is skipped and named.

tools/labels.mjs and hooks/atlas-labels.js are the labels: a table in <vault>/.atlas/labels.json, and a PostToolUse hook on Grep and Read that attaches the label of any symbol a result names, with the successor and the reason. Code is never deleted, it is marked, and it cannot be found without the mark. Silent when the directory has no vault. hooks/atlas-precompact.js, on PreCompact, keeps the session's decision-shaped lines in <vault>/.atlas/harvest/ before the conversation is compacted, as raw material for harvest run, and hands them back as context when the session resumes on its summary; nothing enters the vault. hooks/atlas-signals.js, on Stop, asks at most three times a session whether one sign in the transcript (a fix, a correction, an undo, a choice) is worth a note: one more turn each time; "signals": false in ~/.claude/atlas.json switches it off. A project's .atlas.json vault counts only when ~/.claude/atlas.json confirms it ("vault" or "vaults").

Two optional layers, each one file, each saying plainly when its dependency is missing: tools/embed.mjs finds a note by meaning (a small multilingual model that runs locally, about 130 MB downloaded once into ~/.atlas/models; needs the @huggingface/transformers package) and tools/lsp.mjs asks a language server who really references a symbol now (TypeScript and Python; needs typescript-language-server or pyright). Both look for their packages beside the tools, in ATLAS_NODE_MODULES, or in the global npm folder.

Subagents

Delegated, never typed. The work stays with them, only the answer comes back — their reads, searches and logs never enter your conversation. That is the whole reason they exist, and the reason to skip one: when you need the material itself, delegating adds a round trip and saves nothing.

Builds

The per-turn reminder

A short line is injected every turn so the level does not drift back to verbose: 27 tokens at low, 32 at high, plus 9 for each of ask, check and silent when on. It names the rules that slip first — and "answer first, only what was asked", the one whose failure costs more than the reminder does.

On a long session this is the largest number on the card. Over 295 turns it is 7,965 tokens, more than twice the entire fixed cost. It scales with turns; everything above scales with nothing.

Configuration

Token figures are tiktoken approximations, not Claude's tokenizer — compare them to each other, not to a bill. The fixed costs above are counted by atlas-test/fixed-costs.mjs. How much each level compresses was measured on an earlier revision of the rules with claude-opus-5-5 on 2026-09-26: 24 English and 24 Italian questions with fixed fact sheets, 2 rounds each, through the real hooks. Output against no plugin, median: low -37% English and -37% Italian, high -46% and -43%; details lost, median: low 1 and 0 of 263, high 0 and 1. Run-to-run noise 0.6 points. The API bills the injected rules at about 1.54 times the tiktoken count. The full tables are in the README.