# spool_status

> The mmw-agent local tool — remember calls that have not reached the server yet.

On this page you will learn what `spool_status` shows and what to do when memories take long to reach the server.

The running example: a developer worked on a train without internet, the assistant saved three decisions, and the developer asks "did my memories reach MMW?".

## Purpose

Since 0.1.9 the local agent [mmw-agent](/agent/overview/) first writes every `remember` to disk, in `~/.mmw/outbox.db`, and only then sends it to the server. If the server is unreachable, the memory waits in this queue and is sent in the background. `spool_status` shows the queue. It answers locally and does not contact the server.

Clients without the agent (claude.ai, ChatGPT, direct HTTP) do not have this tool: their `remember` goes straight to the server.

Annotations: `readOnlyHint: true`, `idempotentHint: true`.

## Parameters

None. The input schema is an empty object.

## Response

| Field | Meaning |
| --- | --- |
| `pending` | Memories waiting for delivery. |
| `delivered` | Memories already delivered through the queue. |
| `failed` | Memories the server refused on the merits (for example, the [Memory Guard](/memory/memory-guard/) fired). They are not retried. |
| `oldest_pending_age_seconds` | How long the oldest memory has been waiting. |
| `next_attempt_at` | When the next delivery attempt happens. |
| `last_error` | Why the last attempt failed, for example the server was unreachable. |
| `recent_failures` | The latest refused memories with the reason. |
| `outbox` | Path of the queue file on your computer. |

## Example

```json
{
  "outbox": "/home/dev/.mmw/outbox.db",
  "pending": 3,
  "delivered": 41,
  "failed": 0,
  "oldest_pending_age_seconds": 1260.4,
  "next_attempt_at": "2026-10-18T16:05:12+00:00",
  "last_error": "[Errno -3] Temporary failure in name resolution",
  "recent_failures": []
}
```

Three memories wait, there is no network. As soon as the internet is back, the agent delivers them in the order they were made.

## How it works

- While the server answers, `remember` goes to the server at once and the assistant gets the server's usual answer.
- If the server is unreachable or overloaded, the assistant gets an answer with status `queued` and an id like `local-…`. This is not an error: the memory is already on disk.
- The agent retries with a growing pause, up to 5 minutes.
- Every memory carries its own idempotency key, so a repeated delivery never creates a copy.
- While older memories wait, new ones queue behind them: a newer version of a fact never overtakes an older one.
- If the server refused the API key, the assistant is told exactly that: "MMW rejected the API key… The memory is kept on this computer". It waits in the queue and is sent once the key is fixed (since 0.1.10).
- A memory not delivered within 7 days or 200 attempts is marked failed and no longer holds up the queue. It stays on disk; send it again with `mmw-agent outbox-retry`.
- Delivered memories are removed from the queue after 7 days.

Queued memories are stored on your computer in plain text, readable only by your user account. Until a memory is delivered, your other devices do not have it.