Projects & rules

Say the name when you save or search, and the project exists from that moment — no folder structure, no setup; starting one costs ten messages. Each project has its own memory, its own knowledge and its own focus, set by a one-line purpose. Locally, storage is your own disk and your own business; hosted, your plan carries a set amount and more can be added when you need it. Your app's memory is just another project, running on the same machinery.

Each project is a specialist. It carries its own memory, its own rules, its own history of decisions. When you open a session in it, your agent arrives already briefed — the rules, where things stand, what was decided last week. You don't re-explain. You don't remind it. The briefing is already there.

The minute that pays for the rest of the project

The highest-value minute in the product is the one you spend setting a project's rules. Write them once — how this project is done, what matters, what to avoid — and every session that opens afterward automatically knows them.

You never tell your project's story twice, not to a new agent and not on a different machine. That one minute is spent once, and the agent that walks in tomorrow already knows.

Notes: where the last session stopped

Your agent writes its own handover — where the work stands, what is live, what comes next — one note per session per project, the last five kept. The next session opens with it. You start the PC, say "continue", and it carries on where it left off.

The team layer, on your terms

When you share, you share on your terms. On hosted memory, a key does not have to be all-powerful. Scope it to chosen projects, read-only or read-write — the right shape for a contractor, a CI job, or a single-purpose agent that has no business seeing the rest of your work. Your brain, your rules, your keys.

Human teams. A contractor gets a key that sees the client project and nothing else. When the engagement ends, you revoke one key — not untangle a shared memory.

Agent fleets. A CI job, a research bot, a single-purpose agent — each gets exactly the memory its job needs. An agent that only reads can never delete.

Multiple harnesses, one memory. Run Claude Code, OpenClaw and Codex against the same Brain — but give each its own key, shaped to how much you trust it. The always-on autonomous agent that talks to the outside world gets read-only on one project; your daily driver gets everything. Shared memory without shared blast radius — the problem every multi-agent setup hits, solved where it belongs.

Deleting is deliberate

Deletion is deliberate Everything you store is yours to delete — a project, an exact phrase, or the whole account, from the panel, behind your own identity. Deleting a project takes its history with it; deleting the account destroys the encrypted memory entirely. What agents can and cannot touch is a separate question, and it has a short answer below.

The gap between saying you'll do something and doing it is where work quietly dies. The Ledger catches that gap. As your conversations are archived, it watches for intentions and turns each one into a row waiting for you.

Say “check the ledger” and your agent brings the rows up one by one — you answer each in a single word. The ones you're done with are gone; the rest stay until you deal with them — or until later work shows them done, dropped or overtaken, and they leave by themselves. No statuses, no stale board; the pile only shrinks. Nothing you meant to do quietly disappears.

A project's memory is private to that project. A procedure belongs to everything you do. Write a markdown playbook once, store it for your whole account, and any agent in any project on any machine can fetch it and follow it — the deploy, the weekly report, the translation run, done the same way every time.

You write the workflow down once and never again. Playbooks are never pruned. The worked example is the atlas: your agent draws the map of your whole system as playbooks, and a rule tells every session it is there. Playbooks and the atlas →

Every project is walled off. Its own curated records, its own rules, its own graph, its own notes, its own plan, its own Ledger. General rules sit above them all and reach every project; a project's own rules reach only it. Playbooks are the one shelf shared across the account, because a procedure written once is meant to run anywhere.

Two clients means two projects and two keys. On hosted memory, a key scoped to one project cannot see another, cannot search another, and cannot be told another exists. The only things that ever look across are ones you ask for: a search made without naming a project, and the proposer when it thinks a session was filed in the wrong place.

Nothing bleeds unless you ask it to.

Rules are standing instructions, loaded with most messages. The rest of the briefing comes at session start: what each project is, where the last sessions left off, and an index of what is known — already in front of your agent before it answers. Set rules for everything you do, or for a single project, and they shape how every agent works, everywhere. Saving or changing a rule costs one message; deleting one is free.

The rules are the curator's syllabus

As you work, the memory reads what was said and keeps what a future session would need: decisions saved, changed facts folded in, the claims reality has overtaken deleted. Your rules are the syllabus that tells it what matters. You write the law once, and it is applied without being asked.

You never file one

No save, no tag, no “remember my context” ritual. The curation happens as you work, not when you remember to ask. You never file anything — and the memory does its work whether or not anyone remembers to query it. A store your agent has to be asked to check is only as good as the model’s willingness to ask; this one does the work itself.

The one thing no model may touch

The raw conversation archive is the original record, and it is out of reach of every agent. The threat is your own agent — a mistake, or a malicious instruction hidden in something it was asked to read — and it still cannot delete a single message or touch your recent history. The archive stays yours.

← How it works Tell your agent to install it