What is next, and what is not happening

A view of how a mind moved

Today the neural map is one photograph: what is true now. The monthly reading is already recorded, so the missing part is showing it — which memories strengthened, which faded, and when you changed your mind.

Consolidation without a subscription

A Coredence plan, where we run the model: for people with no account anywhere. It is chosen on purpose, never by default, and even then the consolidation stays on your machine — only the model call passes through the server, never the mind. What is finished is the engine side; the sale is not open yet.

Knowing what a consolidation costs, before it runs

The engine splits the waiting events into windows, builds the prompts it would send, and counts the tokens — without making a single call. It also knows which of three things that count means: money per token on your own key, an allowance on a subscription, a monthly allowance on a plan. Showing a dollar figure to all three would invent a cost for two of them.

Paying less for work that is not urgent

The repeated context — the list of existing memories, measured at 63% of a consolidation prompt — is now cached, and a batch queue sends every window together for the first pass over a long history. Measured on a real mind: $0.105 per window instead of $0.178.

Explaining itself

The window says what it reads, what it produced and where the mind lives — from real data, with an example memory out of your own mind rather than an invented one. It appears on the first launch and stays a click away after that.

A crash leaves a trace

If the window closes unexpectedly it writes what happened to a local file and shows it the next time it opens. Sending it is your decision: no crash reporter is wired in, because a window that opens no sockets is worth more to you than a crash report is to us.

Watching the mind change

What appeared in a month, what faded, what came into conflict with itself, which balance moved. The numbers come from the engine; the screen does no arithmetic of its own, because the query that defines what changed in a month must not give two different answers in two windows.

Sharing a slice, deliberately

Handing one cortex or one layer to somebody else without handing over the whole mind. The file says it is a slice — how many memories are here, how many were left out on purpose. What will be shared is shown before anything is written, because that is what makes it deliberate; and a typo does not drop the filter and send the whole mind.

Windows

The engine and the window both run there, and the window is the same one the Mac has: the mind as a neural map you can walk around in, the detail panel behind every memory, the queue of things waiting on your verdict, and the filter that decides what counts. One download carrying its own Python, and a double-click that walks the whole setup. The two windows are held together by tests rather than by resemblance.

A mind that keeps itself up to date

Reading your sources and consolidating them used to happen once, on the first-run screen. Now there is an hourly consolidation cycle, a keystroke to run one when you want it, and a switch to turn it off.

Handing the mind to your assistant

An MCP server, running on your machine, that lets the tools you already use read the mind — what you think about a subject, which traces a memory grew from. A local process the client starts over stdio: no network, no account, no key. Read-only, because changing the mind is yours.

Every client, not just one

The Assistants tab lists what it finds on the machine — Claude, Claude Code, Cursor, Windsurf, VS Code — and connects any of them without touching the servers you already had.

The engine, inside the app

One download. No Python to install, no repository to clone, no terminal.

Choosing what an assistant sees

Traces in three degrees, a signal-strength floor of its own, and cortices that can be held back — a hidden cortex takes its memories with it.

Notes and messages

Apple Notes and Messages are read too, so the mind no longer rests only on what you typed at an assistant. Only what you wrote is read from a conversation.

Freshness as a colour

A fifth way to colour the neural map: when a memory was last seen. Green is from this quarter, grey is older than three months. A mind is not still, and now it does not pretend to be.

Taking the mind with you

Export to Markdown or JSON, from the File menu or the command line. The text of the traces stays out unless you ask for it, so the file is something you can hand to a tool without handing over what other people wrote.

Seeing what was read

Settings → Sources counts what came from where and which model was called. The privacy claim was checkable with lsof; now it is checkable in the window.

An account

Nothing the product does needs one, and having one would make “it stays on your machine” a thing we ask you to believe rather than a thing you can check.

Publishing the engine, for now

The claims that matter are checkable without it, and more conclusively — lsof and sqlite3 say what is happening rather than what should. Opening later stays possible; closing again would not be.

Hosted consolidation

Reading your work on somebody else's computer is the thing this product exists not to do, however much faster it would be. The paid plan is not an exception: there too the consolidation happens on your machine — the prompt is built here, the memories are formed here, the traces are linked here. The only thing relayed through us is the model call, because we pay for the model.

Letting the app write

The viewer stays read-only. The signal-strength formula and the requirement that every memory keeps its traces live in the engine; a second copy inside the app is how the two would start disagreeing about who you are.

Guessing to fill gaps

A thin mind is honest. Padding it with plausible-sounding memories would make the map look better and the product worthless.