The memory walker · Semantix

Recall only works on things that were written down. The walker is how a conversation gets written down while it is happening.

After each reply it reads what was said since it last looked, distils it to what's worth keeping, and files that into the agent's memory — so the next conversation opens knowing it. There is nothing to type and nothing to remember at the end of a session: by the time you close it, everything durable is already in.

How it walks#

It runs in the background, after the reply has landed on disk, and it never takes the keyboard. When something is filed, a small footprint chip appears under the turn — 2 new, 1 updated → studio — and clicking it lists the memory names. A walk that files nothing leaves no chip, so every chip in a transcript is a memory that exists — with one exception: a walk that reached only for names the agent had carved itself leaves a chip reading 3 protected, because the agent's own carve stands and the walker declined to overwrite it. Expand the chip and each one reads — own carve, kept.

It is allowed to wait. A question asked and not yet answered, a plan mid-discussion, an approach being tried whose outcome is still unknown — carving those now would record a half-fact. The walker may answer not yet and leave the turns unfiled; they come back to it, together with what follows, on the next walk. It cannot wait forever: past a dozen unfiled turns it has to decide.

Settings → Privacy → Walk memory every sets the pace — every turn by default, up to 50. Raise it if you would rather it read a few turns at once; the turns in between are not skipped, only batched.

It keeps a ledger. Every turn a walk distilled is marked, so nothing is ever paid for twice: a walk that finds every turn marked answers nothing new without calling anything, and only what was said since the last walk goes to the distiller — with the last few marked turns riding along as context it may read but not carve from.

Bringing many conversations in at once#

The same pass runs in the background over a whole project from Project Manager → (the project) → Conversations. The panel counts the conversations that still owe a pass — the ones you had before memory was on, and everything an import from Claude Code just brought in — and Ingest N into memory runs the same pass over them one at a time.

Two settings sit beside the button, both remembered. The pause between conversations, in seconds: a big run on a rate-limited key wants breathing room. And where to start from: oldest first (the default) grows memory in the order the work happened; newest first puts the recent past in memory before a long run is over, which is the better choice when you want to keep working while it runs.

The button is greyed out until two things are true: the project's Memory switch above it is on (Turn memory on above to bring them in), and a Primary or Secondary seat is set (Needs one of your own API-key models first — set it as Primary under Settings → Studio → "Semantix's own models").

The run happens on the server, not in the window. While it runs, the panel shows a progress bar, the conversation it is on and what it is doing with it — reading, distilling on your model (with a live timer), stamping — the running tally of memories created and updated, an estimate of what is left, and a log of the last few conversations with the memory names each one produced. A small pill in the header shows the count wherever you are in the IDE; click it to come back to the page.

Close the Project Manager and the run goes on; open it again and the bar is where it got to. A conversation that fails is counted and stepped past — the run never dies on one bad call — unless the first few all fail the same way, in which case it gives up and says why rather than failing every one of them. Only one ingest runs at a time across all your projects.

Taking hold of a run#

A big ingest can run for hours, so four buttons sit under the bar.

Pause holds the run after the conversation it is on — that one lands first, because its tokens are already spent — and then it sits for as long as you like. Nothing is lost while it waits, and Resume picks up exactly where it stopped. Time spent held is kept out of the "about N left" estimate, so a night of Pause does not make the model look slow.

Restart this one throws away the distill in progress and begins the same conversation again on a fresh call. This is the answer to a stall: when the line says no output for 2m 14s — stalled?, the call is usually dead rather than slow, and a new one costs a minute instead of the fifteen the timeout would take. The panel then shows restarted 1× beside the conversation.

Skip moves on to the next conversation. The skipped one is left owed — nothing is stamped — so it shows up again in the count and a later run reads it. Skip is for a conversation that keeps failing, not for one you want out of memory for good.

Stop after this one ends the run. The panel then reads Stopped — N ingested, … and the button reads Ingest N into memory again for whatever is still owed.

Everything is on the ledger, so nothing is ever lost: if the IDE crashes or is closed mid-run, what it finished is in memory, and the panel says so on the next open — A run was interrupted at 41 of 372 — with the button offering to Continue — 331 left.

What it costs#

The run keeps its own bill, and it ticks while the model types. The panel and the header pill show the running total with the split (in, out, thinking) and the rate on hover. Each conversation in the log carries its own figure too, and the bill is written into the run record, so an interrupted run still says what it spent.

The dollars come from the model's price on file: a custom model's own $/1M under Settings → Models, or the provider's catalogue for a connected provider. A model with no price on file shows tokens alone rather than a figure nobody computed.

What it keeps#

Not the transcript. The pass reads the conversation and writes a handful of durable notes out of it — decisions, constraints, things about your project that will still be true next week.

The chip names them, so you can see what it took: how many were created, how many updated, and the agent they went to.

Note

Tool noise is shed before the pass reads anything — it sees the conversation, not the file reads and shell commands in between. The exception is a tool whose memory switch you turned on in Settings → Tools: its calls ride the pass as the agent's own turns, cut to a couple of thousand characters each. The agent's own writes — a memory it carved, a note to its crew — always ride: they are its words, and they need no switch.

Which model does the distilling#

Not the model you were talking to. The walker uses, in order:

the Primary seat under Settings → Studio → "Semantix's own models"
failing that, the Secondary seat
failing that, the model answering this conversation

That order exists so the distilling can be done by something small and cheap while you talk to something expensive. Putting a cheap model in the Primary seat is the intended setup, not a compromise.

When it refuses#

It needs one of your own API-key models. The distilling runs through a model Semantix calls directly — a connected provider's model or a custom endpoint — not Claude Code, which has no API endpoint for Semantix to dial.

Important

A seat that is set wins even if it cannot work. The list above stops at the first seat that holds anything — not the first that can actually distill. So if Primary holds a model Semantix can't call, the walker fails there and never reaches step 3, even when the conversation you are in is already running on a perfectly good API-key model. Changing the conversation's model will not rescue it; the seat is what has to change.

When it refuses, it says so in the transcript, once per conversation, as a warning notice titled Memory:

The memory walker can't run on Claude Code (claude_code:haiku) — it has no API endpoint for Semantix to call. Switch to an API-based model. Change the Primary model under Settings → Studio → "Semantix's own models".

or, with no seat set at all:

The memory walker needs an API-based model of your own. Set one as Primary under Settings → Studio → "Semantix's own models".

The fix is to put one of your API-key models in the Primary seat. It doesn't have to be the one you chat with.

Note

If chips never appear on a conversation that clearly held decisions, the seat is the first thing to check — then the project's own Memory switch in the Project Manager.

→ Semantix's own models · What it recalls as you type · What's stored, and where