OpenClaw

OpenClaw runs a personal agent across your chats. Its memory is a plugin slot, and the Recall plugin fills it: before each turn the agent sees what Recall remembers, after each turn Recall learns from the conversation, and the agent has tools to search, store and forget on its own. A correction replaces the old fact, the history stays, and the agent can read memory as of any earlier time.

Why Recall here

A personal agent hears facts that change: a new address, a new job, a preference that flipped. In a search index both versions come back and the model picks one. Recall decides at write time. "I moved to Bellevue" replaces "I live in Seattle", the agent gets the current value with what it replaced, and the old statement stays readable in the history. Nothing is deleted, so memory_search with as_of answers what was believed last month.

The memories live in your own polign_db, on local disk or in your bucket. OpenClaw holds one Recall key, and the key names the namespace, so one server can hold memory for many agents without any of them reaching another's records.

Before you start

OpenClaw 2026.10.2 or later, on Node 24.16 or later.
recall 0.16.0 or later: brew install polign/tap/recall or pip install polign-recall. Either way you also get polign-server.
A model that works facts out of text, as provider:model: a hosted one such as anthropic:claude-haiku-4-5-20251001 with its key in the environment, or a local one such as ollama:qwen3:8b. Without one, Recall keeps captured text as written: searchable, but nothing replaces anything, and forgetting by description is refused. A small local model misses some phrasings; in testing, qwen3:8b caught "I live in Bellevue now" but not "I moved to Bellevue last week".

Run the memory server

Start polign_db and recall serve in text mode:

polign-server -store fs:$HOME/.local/share/polign/openclaw
recall -url http://127.0.0.1:23000 serve -text -listen 127.0.0.1:8080 \
  -extract-model anthropic:claude-haiku-4-5-20251001

Both listen on loopback by default. -store takes an S3, GCS or Azure URL as well as a local path; see Run polign_db.

Mint a key for OpenClaw:
```
recall -url http://127.0.0.1:23000 key create -namespace openclaw -expires 8760h
```
It prints a key that starts with rcl_, once. That is the only credential the plugin needs.

Install the plugin

```
openclaw plugins install clawhub:@polign/openclaw-recall
```
It is listed on ClawHub as Recall by Polign, so openclaw plugins search polign finds it too. The same package is on npm; installing from there asks you to confirm, and a script needs --force --accept-capabilities. The local example runs polign_db, Recall and every step below with one script.
In openclaw.json, make Recall the memory engine and allow the hooks:
```
{
  "plugins": {
    "slots": { "memory": "recall" },
    "entries": {
      "recall": {
        "enabled": true,
        "hooks": { "allowConversationAccess": true },
        "config": {
          "url": "http://127.0.0.1:8080",
          "apiKey": "${RECALL_API_KEY}"
        }
      }
    }
  }
}
```
slots.memory replaces the built-in memory with Recall. hooks.allowConversationAccess lets the plugin read the prompt and the turn's messages, which auto-recall and auto-capture need; OpenClaw asks this of every plugin it did not ship. Put the key in RECALL_API_KEY, or write it in place of ${RECALL_API_KEY}.
Turn off the built-in memory plugin:
```
openclaw plugins disable memory-core
```
OpenClaw 2026.10 keeps it loaded even when the slot points elsewhere, and it registers memory_search first. Without this step the agent's searches go to the workspace Markdown files instead of Recall.

Restart the gateway and try it:

openclaw recall status
openclaw recall remember "I moved to Bellevue and I prefer concise answers"
openclaw recall search "where does the user live?"

What the agent gets

Tool	What it does
`memory_search`	Asks what is remembered, in words. Each answer shows when it was stated and what it replaced. `as_of` answers as of an earlier time.
`memory_store`	Keeps a preference, a fact, a decision or a correction. Recall works out the statements; a newer one replaces an older one about the same thing, and restating something known changes nothing.
`memory_forget`	Stops believing what a description names, such as "my editor". Nothing is deleted, and remembering it again brings it back.

Two hooks are on by default. Auto-recall asks Recall about the user's message and puts up to five answers in front of the prompt, in a <relevant-memories> block; when Recall has nothing to say or does not answer, nothing is added. Auto-capture sends the latest ten user and assistant messages to Recall after a successful turn, with any injected memory block stripped first so memory never feeds itself. Captures run in the background, one at a time, because extraction can take longer than the 30 seconds OpenClaw waits for a hook. They need a process that stays up, such as the gateway; a one-shot openclaw agent --local exits before the capture finishes.

Settings

All under plugins.entries.recall.config.

Setting	Default	Meaning
`url`	`$RECALL_URL`, then `http://127.0.0.1:8080`	Where `recall serve` listens.
`apiKey`	`$RECALL_API_KEY`	A Recall key. It chooses the namespace.
`autoRecall`	`true`	Put relevant memories in front of each prompt.
`autoCapture`	`true`	Send the recent conversation to Recall after each turn.
`maxMemories`	`5`	How many memories auto-recall injects.
`captureMessages`	`10`	How many of the latest messages auto-capture sends.
`timeoutMs`	`60000`	How long the agent's memory tools wait. Storing waits for the extraction model. Auto-recall waits at most 10 seconds.
`captureTimeoutMs`	`120000`	How long one background capture waits.

What works differently from the built-in memory

Built-in memory	With Recall
Markdown files in the workspace (`MEMORY.md`, daily notes)	Statements in polign_db. The files are neither read nor written.
Search over file contents	Search over current beliefs, each with what it replaced. The history is kept but hidden unless asked for with `as_of`.
No server to run	`recall serve` must be running. When it is not, the hooks log a warning and add nothing, and the tools report the error to the agent.
A list of everything remembered	No list tool. Ask a broad question with `openclaw recall search`, or run `recall explain` against the server.

If something goes wrong

What you see	What to do
`recall: no key configured` in the gateway log	Set `apiKey` in the plugin config or `RECALL_API_KEY` in the gateway's environment.
`unauthenticated: the key is not known or no longer valid`	The key was revoked, expired, or minted against another database or collection. Mint a new one with `recall key create`.
`typed hook "before_prompt_build" blocked` in `openclaw plugins inspect recall --runtime`	Add `"hooks": { "allowConversationAccess": true }` under `plugins.entries.recall`.
`plugin tool name conflict (recall): memory_search` in the gateway log	Run `openclaw plugins disable memory-core` and restart the gateway.
`auto-capture skipped: ... aborted due to timeout`	Extraction took longer than `captureTimeoutMs`. Raise it, or use a faster extraction model.
`This server has no extraction model, so the text was kept as written`	Start `recall serve` with `-extract-model` and the provider's key in the environment.
`unreachable: Recall at ... did not answer`	`recall serve` is not listening at `url`. Check the address and that it was started with `-listen` on that port.

Source & license

The plugin is open source under the Apache License 2.0, in github.com/Polign/polign, and is written against the HTTP contract in Recall's Memory API, version 1. Bug reports and pull requests go there.