Skip to main content
Memory is how an agent carries something forward. A run that worked out why a service was slow can write that down, and a later run of the same agent finds it instead of re-deriving it. Agents reach it through two tools — one to search, one to save — and call them on their own judgement. Find it under Build → Memory.
Memory is per agent, not per account. What one agent learned is invisible to another until they share a space.

​
Setting it up

Three things have to be true before an agent remembers anything.
1

Create a space

A space holds the memories for one area of work, under a name you choose — for example Cloud and observability or Kubernetes RCA. Name it for the work rather than the agent, since more than one agent can end up sharing it. New space creates one; Manage spaces lists them with their memory and agent counts.
2

Bind the agents that should share it

Choose agents on a space binds them. An agent writes to exactly one space and cannot be bound to a second, so sharing runs the other way: putting two agents in one space is how one agent’s learning reaches another. Bind nothing and an agent’s memories are its own.
3

Deploy the Memorizer, and point the space at it

Every memory is reviewed before anyone can read it, and the reviewer is itself an agent: Memorizer, from the agent catalog. Deploy one per account — it needs no integrations, only the managed LLM credential, and it is never chatted with or invoked by hand.It arrives already carrying the label the platform resolves it by, so a space left on Find by role finds it with nothing else to configure. Choose a specific agent on the space only if you want that space reviewed by a different one.
A space with no reviewer records nothing. Memories stay unreviewed drafts, invisible to search, while agents go on saving — silently, since saving still looks like it works. The space flags it, and waiting drafts are reviewed as soon as a reviewer exists.

​
The four statuses

An agent often saves the same lesson several times in one run, worded differently each time. Drafts are what stop all of them being published: the Memorizer sees them together and keeps one.

​
What happens after a run

Three stages, and each one is an ordinary run you can open and read.
1

The agent is asked what to remember

The same agent resumes a copy of its own thread and is asked what should be remembered. It answers with the full context of the work it just did, rather than a summary of it. Because the thread is copied, the conversation you were having is never touched.
2

The drafts are reviewed

The Memorizer is handed the drafts, the run’s transcript, and any existing memories the drafts may duplicate — so the decision is made with the alternatives in view.
3

The decision is applied

Each draft is promoted, rewritten, merged into an existing memory, or rejected. The space’s activity reports the outcome plainly: 2 created, 1 combined, 1 removed.

​
Writing the same thing twice writes it once

Review catches near-duplicates. Exact ones never get that far: a write whose text already exists in the agent’s space returns the existing memory rather than adding a second copy, so an agent that re-learns the same fact verbatim does not inflate the space.

​
A coherence pass runs on the space itself

Every six hours a sweep asks a question no single run can: is this space still coherent? Two memories written weeks apart that say the same thing, one that contradicts another, wording that has aged badly — none of that is visible to a pass looking at one run’s output. A space with nothing new in the window is skipped — but a single memory is enough to sweep on. The duplicate it needs comparing against is found by searching the space, not by being handed over beside it.

​
Checking that it is working

Activity is where you find out whether memory is earning its keep.
A lopsided first card is healthy — most sessions should teach nothing, and a fleet that learns from every run is writing noise. Worry instead when nothing is being read, which Most read memories shows.
What memory is doing is the running log — each sweep and each review, with what it kept and the run behind it.

​
Curating what it remembers

Manage memories is the librarian’s view: every memory, filtered by space and by status, with Edit and Archive on each. Archive the ones that have aged out; edit the ones that are nearly right. Each memory carries a kind the agent chose when it wrote — technique, pointer, constraint, fact, feedback, or preference — and labels as key: value pairs, like topic: slack-formatting or tool: datadog. Labels are not decoration: a hit that matches on label ranks above one that does not. Labels governs that vocabulary, per space, in two lists:
  • Entities — dimensions you have declared, through Declare dimension. You give each a key and a description of what it holds.
  • Agent labels — keys agents invented while writing, held separately so you can see what the fleet reached for that you never declared.
Declaring one changes what gets written. Your keys and their descriptions are handed to the agent as it decides what to remember, so it labels with your vocabulary instead of inventing a near-synonym for something you already track — which is how service and svc end up as two dimensions. A match on a declared key also counts for a little more, enough to settle a tie between two equally rare labels and no more. So a key agents keep inventing is a dimension your space was missing: promote it and they start using it. Going the other way, Stop tracking keeps every label already applied — it only stops the key being offered to writers.

​
How a search finds a memory

A search runs two ways at once — keyword matching and meaning-based matching — and the results are fused into one ranking. Ranking is by each hit’s position in that fused list rather than by its raw score, because the two methods produce scores on scales an order of magnitude apart; ranking on the raw number put every meaning-matched memory above every keyword-matched one regardless of the evidence.
An active memory never expires. Nothing retires one by age — that is your call, or the coherence pass’s — so a space needs an owner rather than cleaning itself. Retiring one starts a clock instead: an archived or superseded memory stays readable and restorable for 90 days, then is deleted for good.

​
Next steps

Knowledge base

Documents you upload, as opposed to what an agent learned on its own.

Runs & evidence

The digest and review stages are runs — open them like any other.

Skills

Know-how you author deliberately, rather than something learned.