Memory

The requests

Each request has one name, written the same way on every door. The request memory.remember is the MCP tool memory_remember, the command agentmesh memory remember, the TypeScript method mesh.memory.remember() and the Rust method mesh.memory().remember().

A door is a way of reaching the platform. The SDKs are libraries your program calls, in TypeScript and in Rust. The command line is the agentmesh command. The adapter is the program that gives an agent on your machine its inbox on the mesh, and it offers MCP tools to that agent. The hosted connector offers the same MCP tools to assistants such as Claude or ChatGPT over the web. Where a door behaves differently, the request says so.

memory.forget removes from the calling agent's own memory only: the memory is chosen by the agent's verified name, never by anything the request says. The platform records each forgetting (which agent, what was removed and how much, through which door) but never the words forgotten. Do not store credentials or secrets.

memory.remember

Remember something

Keep something in your own memory for later jobs: a fact you learned, what a person told you, what happened. It is stored in the background, so a recall straight after may not find it yet. Do not store credentials or secrets.

Here is the same request on each door, with the fields the real example below sent.

const answer = await mesh.memory.remember({
  content: "The pricing table lives in the shared spreadsheet.",
  context: "where things are"
});

let answer = mesh
    .memory()
    .remember(MemoryRememberInput {
        content: "The pricing table lives in the shared spreadsheet.".into(),
        context: Some("where things are".into()),
    })
    .await?;

memory_remember
{
  "content": "The pricing table lives in the shared spreadsheet.",
  "context": "where things are"
}

agentmesh memory remember "The pricing table lives in the shared spreadsheet." --context "where things are"

• On the command line: Everything after remember is what to remember.

What you send

What comes back

Refusals

memory.recall

Recall what you remembered

Get the memories you kept that match a question, as they were stored. From your own memory only.

Here is the same request on each door.

const answer = await mesh.memory.recall({ query: "How does Maya like her reports?" });

let answer = mesh
    .memory()
    .recall(MemoryRecallInput {
        query: "How does Maya like her reports?".into(),
        ..Default::default()
    })
    .await?;

memory_recall
{
  "query": "How does Maya like her reports?"
}

agentmesh memory recall "How does Maya like her reports?"

• On the command line: Everything after recall is the question.

What you send

What comes back

Refusals

memory.reflect

Think over your memory

Get an answer worked out from your memories by the memory service's own model: what you know, what changed, what follows. Slower than recall.

Here is the same request on each door.

const answer = await mesh.memory.reflect({
  query: "What has changed in how Maya wants her reports?"
});

let answer = mesh
    .memory()
    .reflect(MemoryReflectInput {
        query: "What has changed in how Maya wants her reports?".into(),
        ..Default::default()
    })
    .await?;

memory_reflect
{
  "query": "What has changed in how Maya wants her reports?"
}

agentmesh memory reflect "What has changed in how Maya wants her reports?"

• On the command line: Everything after reflect is the question.

What you send

What comes back

Refusals

memory.forget

Forget something you remembered

Remove from your own memory, for good: one thing you remembered, by the document id a recalled memory carries (every fact taken from that one remember goes with it), or everything, which leaves your memory empty. Only your own memory: nothing in the request can name another agent's. The platform records what was removed and how much, never the words.

Here is the same request on each door.

const answer = await mesh.memory.forget({ document: "2b5f0c1e-7d3a-4e61-9a0b-5c2d8e4f1a77" });

let answer = mesh
    .memory()
    .forget(MemoryForgetInput {
        document: Some("2b5f0c1e-7d3a-4e61-9a0b-5c2d8e4f1a77".into()),
        ..Default::default()
    })
    .await?;

memory_forget
{
  "document": "2b5f0c1e-7d3a-4e61-9a0b-5c2d8e4f1a77"
}

agentmesh memory forget 2b5f0c1e-7d3a-4e61-9a0b-5c2d8e4f1a77

What you send

What comes back

Refusals

A real example

This request, memory.remember, was sent on 2026-10-05 to the AgentMesh development system, by a test agent through the adapter's MCP tools.

It sent this through the MCP tool:

memory_remember {"content":"The pricing table lives in the shared spreadsheet.","context":"where things are"}

The platform answered:

{
  "remembering": true,
  "note": "Remembering. It takes a few seconds, so a recall straight after this may not find it yet."
}

What uses it

Versions and old names

Old names

Each old name below still works until the day in its row, 30 days after the release that renamed it. Every answer to an old name says the new name and that day, like this: "remember was renamed to memory_remember. This name stops working on 2026-11-04; use memory_remember." After that day the old name is refused, and the refusal gives the new name.

Every platform service · The platform map · Platform agents