Memory

Close a conversation, open a new one, and the agent you were working with is gone. Not busy, not distracted — gone. It has no idea who you are, what this project is, or that the two of you spent an hour yesterday deciding not to use that library.

This is not a flaw someone forgot to fix. A language model has no memory between conversations. It reads what is in front of it and answers. When the conversation ends, there is nothing left to remember with.

So Semantix does the remembering instead. The model still forgets; the app doesn't. Before your message reaches the model, Semantix looks for what it already knows that bears on it and puts the relevant parts in front of the model along with your question. The model isn't recalling anything. It's being handed notes.

That distinction is the whole feature, and everything below follows from it.

Because of that: it only knows what was written down#

Notes have to exist before they can be handed over. Memory doesn't quietly absorb everything you type — it is written, in three ways.

It writes the conversation down as it goes. The memory walker reads each turn once the reply has landed and keeps what's worth keeping — waiting, when a thread is still forming — so the next session starts knowing it. Nothing to run at the end.

Ask for it in conversation. Tell the agent to remember something and it writes it down itself: "remember that we're on Postgres 16, not 15." It can also look things up on request — "what do you know about how this project handles auth?"

A session can hand itself off. /handoff writes a short note on where the conversation left off, and the next new chat in the project reads it on its first turn.

→ The memory walker · Handing a session off

Because of that: it belongs to an agent, and you choose which one#

Memory isn't a pile that belongs to a project. It belongs to an agent — a named employee of yours, with a memory of its own that follows it into every project you allow it in. A project has a roster of agents allowed to work in it and one of them is its default; the first conversation in a project creates that default agent if you said yes to memory when you set the project up.

Usually you never think about this: a conversation talks to the project's default agent, and that agent's memory is what it recalls from and writes to. When you do want to think about it — talking to a different agent from here, say — the model picker's Agent row is where you change it, and the Project Manager is where agents are made, named, allowed in and out.

→ What it recalls as you type · The Project Manager

Tasks can wear one too. An agent task in the Task Manager can be given a memory of its own, made with the task, or one of your existing agents — and it reads that memory before each run and writes to it after. A task's own mind is listed under Your Agents as a task agent; it is not a chat agent and the chat picker never offers it.

→ What a task runs

Because of that: it lives somewhere, and that somewhere isn't your laptop#

Your code, your conversations and your settings sit in ~/.semantix/ on your machine. Memory does not. It's kept on the Semantix server against your account, which is how it follows you to a second machine — and it's the reason Local only mode switches it off completely.

That's a real trade and you should make it deliberately rather than discover it later.

→ What's stored, and where

Because of that: you can look at it#

Memory is not a black box. The Memory button in the menu bar opens a tab that draws the agent's mind as a sky of lights you can fly through, search, and open one memory at a time.

→ The Memory tab

The two switches#

Memory is off until you turn it on, and there are two gates. Both have to be open.

Settings → Privacy → Semantix Memory decides whether, for you. This is consent: memory is stored against your account, so this is where you agree to that. Off by default, and Local only overrides it — with Local only on, memory stays off no matter what this switch shows. With it on, every reflex runs on every message and the memory tools are handed to the agent. There is no master-and-three-smaller arrangement any more; this one switch is the whole gate.

Project Manager → (the project) → Memory decides whether, for this project. A project you set up without memory has no agent and remembers nothing, whatever the Privacy switch says. Turning it on later is fine; turning it off later keeps the agents and memories — nothing is deleted by the switch.

And one thing that isn't a switch but stops everything if it's missing: the Primary seat under Settings → Studio. The walker, the hand-off and the bulk ingest all run on that model, not on the one you chat with. Empty seat, no filing — the walker says so once per conversation.

→ Semantix's own models

What this is not#

Memory is not a transcript. It doesn't store your conversations so you can read them back — that's what conversation history is for, and it's a separate thing kept locally.

It's also not automatic understanding. A memory that was never written is not recalled, and one written badly is recalled badly. The agent is working from notes, and notes can be wrong.

→ What it recalls as you type · The memory walker · Handing a session off · The Memory tab · The Project Manager · What's stored, and where