How it works

The whole design rests on one idea: you stop being your own memory. Seven things do the remembering — curated records, rules, the full chat history, the graph, notes, playbooks and the Ledger — and most of what matters is already in front of your agent before it answers.

You never file anything

Every session your agent runs flows through the Brain. What's said is archived; what the memory knows comes back before it's needed. You never see it happen — you just notice you stopped re-explaining yourself. One choice at signup: local, with the memory stored on your own machine and nowhere else — or hosted, encrypted under a passphrase only you hold. Either way, we only process your memory; we never store it.

In: everything is archived

Your messages, your agent's replies, its thinking — the complete transcript of every session, kept in full and searchable any way you like. No summary decides what survives. Recall never depends on what fit in a context window.

Out: rules and memory arrive on their own

Every session starts with your agent already briefed on the project — its rules, where things stand, what was decided.

And before every prompt, the matching memory is pulled in so the agent has it when it starts answering.

No tool calls, no hunting, no remembering to ask — most of the time. When the brief and the records that arrived are not enough, everything ever said can be searched.

Where it happens

Every conversation passes through our hub — that is how memory gets made. The hub only processes: it runs in a secure compute instance in Zurich, Switzerland, holds each piece only long enough to be understood, and keeps none of it. The thinking is done by a model whose provider is contractually bound to retain nothing. Your memory itself lives on your own machine (local) or encrypted under a passphrase only you hold (hosted) — and it answers before you ask.

Memory that learns while you work

Session start

Never explain your project twice — not to any agent, not on any machine. Start the PC, open the session, say "continue", and you're back where you left off. Your agent knows the rules, the decisions, the current state — and where the last session left off. Only you are allowed to forget.

Per-prompt: the memory arrives before the answer

Rules arrive with almost every message, and the records that bear on a prompt arrive with it, before the agent starts answering. It spends no tool calls, no turns, no hunting — the memory is simply there, most of the time. Every other memory store waits to be asked; this one does the work itself. And when that is not enough, your agent searches — everything ever said is there.

As you work: the curator rewrites memory

As you work, the memory reads what was said, a few exchanges at a time, and keeps what a future session would need: decisions saved, changed facts folded in, claims reality has overtaken deleted, new facts reconciled against old ones. Reading a stretch at once, it keeps what the conversation settled, not every half-thought on the way. Nothing has to be filed by hand for the memory to build itself.

Say continue — it already knows. Briefed before you type a word: rules with almost every message, the records that matter with the prompt, everything ever said searchable, notes, playbooks, the Ledger.

When you *want* something remembered on the spot, you say so and your agent records it. But that's a convenience, never a requirement.

Two memories, working together

Two memories, one payoff: your agent always works from the current truth, and the raw "why" is never lost. Curated memory is the truth — dense, up to date, what your agent works from. The conversation history is the complete recording — everything ever said, so no summary ever decides what survives.

Curated memory

This is the memory your agent works from — what is true right now. Reverse a decision and the record changes with it. The old way also stays on record as the old way, with the day and the reason it was replaced, and your agent stops proposing the thing you killed in March — the line saying so comes back with the search. Nothing to check, nothing to police.

Full chat memory: the complete recording

Every session, kept in full. No compression, no summary that decides what matters. When you need to know exactly what was said — or why a decision was made — it's all there, searchable by keyword or by meaning. And it is protected: it cannot be deleted piecemeal, not even by your own agent.

Notes: the handover

Your agent writes where it stopped — what is live, what comes next — one note per session per project, the last five kept, and the next session opens with it. Start the PC, say "continue", and it carries on. If a note was never written, the conversation that produced the moment is still in the archive.

Find it any way you remember it

Full-text

Exact words. When you remember the phrase, find the phrase. Exact-match search across the whole memory.

Semantic (vector)

When you only remember what it was about, semantic search finds it anyway. You don't need to get the wording right.

Graph

The graph is the memory of decisions. Every decision, dated, with its reason and the option it beat — and what was tried, rejected or dropped along the way. Ask "why is it like this?" and get the answer in the words of the conversation that decided it. Search your memory and the records come first, the decision lines under them, each marked with its day and what happened. It's part of every plan, on both editions — an exchange is one message, the graph included.

The things you said you'd do

The Ledger watches your conversations and catches the things you said you'd do and never did. The gap between talking and doing is where work dies. This is the thing that makes sure it doesn't.

👀

It listens for intentions

As conversations are archived, the Ledger watches for intentions — "I'll fix that later," "we should follow up on this" — and each becomes a row waiting for you. The idea you voiced at 2 a.m. doesn't evaporate. It's a row on a list when you wake up.

⚖️

You decide in seconds

Say “check the ledger” and your agent brings the rows up one by one. You answer in single words. Every answer removes its row, so the pile only ever shrinks. No statuses, no stale board.

What still matters joins the plan

A row that still matters becomes one line in the project’s plan — Next or Parked — and leaves the Ledger; the rest dies. The plan opens the next session, so what you meant to do is in front of your agent when the work starts.

No statuses, no stale task board, no pile — the ledger holds only what’s undecided, and every decision shrinks it. It keeps itself clean of the obvious too: a repeat or a passing step is never filed, and a row the later work shows done, dropped or overtaken leaves by itself.

Write a procedure once. Run it from anywhere

The deploy, the weekly report, the translation run — write it down once as a markdown playbook, stored for your whole account.

Any of your agents, in any project, on any machine, can fetch it and run it. Projects are separate; procedures are shared.

The Brain never runs the playbook itself — there's no execution backend, no terminal, no access to your machines. Your agent does the work.

Playbooks are yours entirely — never pruned, never touched by the tidying: records are cleaned up as state moves on, procedures stay. The worked example is the atlas — your agent draws the map of your whole system as playbooks, and every session after loads it. Playbooks and the atlas →

What runs without you

Your memory keeps itself in order as you work — each stretch of conversation is reconciled against what is already known —

and merges records that forked apart,

absorbs duplicates written months apart,

and reconciles the places where memory disagrees with itself.

The Ledger catches, in the background, the things that were said and meant, for you to check later.

Nothing to remember. No "save my context" ritual.

You don’t manage any of it. That is the product.

Start free — just ask your agent to install it Projects & rules →

Hear it when it ships

New releases, real benchmarks and the occasional deep-dive. No spam, unsubscribe in one click.

Everything we build

External:   YouTube · GitHub