Memory agents
choose to use.
Turn on persistent memory and your agent gets two tools — remember and recall. The model decides when to use them. Every call is scoped to the agent's credential, recorded with the run, and reachable from your AI assistant over MCP.
Tools added
- memory.rememberinjected
- memory.recallinjected
A tool, not a hidden round-trip.
Memory is not bolted onto every message behind your back. It is a tool the agent reaches for when it needs to — which means it shows up in the run record and the lineage graph like any other call.
Turn it on
Flip “Enable persistent memory” on an agent. Two tools appear alongside your own: remember and recall.
The agent decides
Mid-task, the model chooses when to save something and when to fetch prior context. It is just another tool call.
Scoped to the agent
Memory access is derived from the agent’s own credential. It can only touch its own memory.
Recorded and revocable
Each remember and recall lands in the run record. Revoke the agent and its memory access stops with it.
// Injected when persistent memory is on.
[
{
"name": "memory.remember",
"description": "Save a note to long-term memory.",
"parameters": { "content": "string", "tags": "string[]?" }
},
{
"name": "memory.recall",
"description": "Fetch relevant notes from memory.",
"parameters": { "query": "string", "limit": "number?" }
}
]Built on Walrus Memory.
Persistent memory runs on Walrus Memory — an open memory layer built for AI agents. Instead of sitting in our database, every note your agent saves is encrypted and kept on an independent, decentralized network that you own. It is the same principle as the rest of Kraterion: your data lives somewhere you control, not somewhere you rent.
Persistent
Memory outlives sessions, restarts, and deploys. Your agent picks up where it left off instead of starting from scratch every time.
Portable
It isn't locked to Kraterion. The same memory can move with your agent across apps and models — no vendor lock-in.
Private
Every note is encrypted before it's stored. The network keeps your memory available but can't read what's inside it.
Verifiable
Each memory is tamper-evident. You can confirm a note is exactly what was written — handy when a decision needs an audit trail.
When the agent calls remember, the note is encrypted and stored; recall searches it back by meaning, not just keywords. Learn about Walrus Memory.
Same memory.
In your editor.
Reachable over MCP.
Kraterion runs an MCP server, so remember and recall work from Claude Desktop, Cursor, or any MCP-compatible client — with the same scoped credentials and the same run record. Your assistant gets durable memory, no code required.
One honest dependency.
Memory runs through Walrus Memory's hosted service — the part that encrypts and stores each note. If you need strict availability guarantees, you can self-host it. Either way, the memory stays encrypted and owned by you.
Give your agents memory
you can take back.
Opt-in. Scoped per agent. Recorded with the run. Revocable in one step.