> ## Documentation Index
> Fetch the complete documentation index at: https://docs.memory.anonalabs.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Temporary profiles

> Let an agent store memories before anyone has an account, then claim the result later.

## What it is

Normally you sign up, then connect an agent. A temporary profile inverts that.
`anona start` gives an agent a working memory **before any account exists**. A
person claims the result afterwards with `anona login`, and the memories the
agent stored while it waited are theirs.

This is path **C** of
[The four ways to connect](https://docs.memory.anonalabs.com/agents/self-onboarding.md#the-four-ways-to-connect),
which is the one table of client against connection path — read it first if you
have not chosen a path yet.

A temporary profile is a memory workspace with no email address, no password
and nobody owning it. The only thing that identifies it is an opaque token
starting `anona_tmp_`, which the CLI keeps in `~/.anona/credentials.json` (mode
600\). The server keeps only a hash of it. The token is never printed, so that
file is its only copy.

That token works wherever an API key does, and on the remote `/mcp` endpoint,
so an agent can use it without a browser or a human in the loop.

On a temporary profile the MCP tools do not need a `space_id`: the profile has
exactly one space and omitting the argument uses it.
That space is `default`, and it is the only one the profile can hold: a write
naming any other space (a CLI `--space`, a REST `space_id`, an upload, an MCP
`space_id`) and `POST /v1/spaces` are refused with `403
temp_profile_single_space`, so a typo cannot quietly create a second space.
Claim the profile to create more.
A signed-in account still has to name one, because an account may hold several
and a memory written to the wrong space looks exactly like success.

## The limits

| | Unclaimed profile | Claimed account |
| - | - | - |
| Credits | **1,000** | 5,000 |
| Lifetime | **72 hours**, then deleted | No expiry |
| Owner | Nobody | You |

> [!WARNING]
>
> **Assume nothing will warn you before the 72 hours are up.** There is no email
> address to send a warning to, so the CLI is the only channel: `anona status`
> prints the deadline whenever you ask, and `anona mcp` prints it once at startup
> inside the last 24 hours, on **stderr** — which many MCP clients never show a
> human. When the deadline passes the profile's memories are deleted and the token
> stops working. Check `anona status`, or claim the profile.

## Start to finish

**1. Install the CLI**

Either package works. They share one credential file, so you can start with
one and claim with the other.

```bash theme={null}
pip install -U anona               # 0.19.0 starts a profile; 0.20.0 adds record/retrieve/reason
npm install -g @anona-labs/memory  # needs 0.16.0 or later; no shell verbs
```

**`-U` matters on pip.** Without it, an existing older copy is left in
place and reported as a success, so `anona record` fails with
`invalid choice`. `anona --help` lists what you actually have. If pip
answers `externally-managed-environment` it is refusing a system Python;
use `uvx` below or `pipx install anona`.

With nothing installed: `uvx --from anona anona start`, or
`npx @anona-labs/memory start`. Both always run the current version, which
makes them the shortest path on a machine that already has an old copy.

**2. Start a profile**

```bash theme={null}
anona start
```

```
Temporary profile created. It expires 2026-10-06 15:22 UTC (in 71 hours), after which its memories are deleted.
The only reminder comes in the last 24 hours: run `anona status` to check, and
`anona login` to claim it and keep what it holds.
Its space, `default`, is normally created now; if a retrieve reports no space, the first memory you write creates it.
```

Note the expiry. If a profile is already stored, `anona start` prints its
deadline and creates nothing.

**3. Connect your client**

The server is a stdio server named `anona`, launched as `anona mcp`.
Register it the way your client does:

| Client | Register it |
| - | - |
| Claude Code | `claude mcp add anona -- anona mcp` |
| Codex | `codex mcp add anona -- anona mcp` |
| Gemini CLI | `gemini mcp add -s user anona anona mcp` |
| OpenCode 2.x | `opencode mcp add anona -- anona mcp` |
| Goose, Cursor, Windsurf, Cline and others | see [the per-client table](https://docs.memory.anonalabs.com/agents/onboarding-prompt.md#2-start-a-temporary-profile) |

Restart the client so it loads the tools. Then `record` something. The
profile's one space, `default`, is created with the profile, so a
`retrieve` before any `record` returns an empty result rather than an
error — and no call needs to name a space.

**4. Or skip the client**

A temporary profile is also usable straight from the shell, which is the
path to take when a client cannot do MCP, or before a restart has loaded
the tools:

```bash theme={null}
anona record   "The user prefers pnpm."
anona retrieve "package manager preference"
anona reason   "how does this team like to build?"
```

On a temporary profile no `--space` is needed: its one space is
`default`. See [record, retrieve, reason](https://docs.memory.anonalabs.com/cli/memory.md).

**5. Check the deadline**

```bash theme={null}
anona status
```

```
Temporary profile for https://memory.anonalabs.com: expires 2026-10-06 15:22 UTC (in 70 hours), after which its memories are deleted.
Run `anona login` to claim it before then.
```

`status` reads only the local file. It cannot tell you the server still
holds the profile.

The CLI's default is `https://memory.anonalabs.com`, not the `api.` host
the rest of these docs use. Both reach the same API. What matters is
keeping to one: the CLI ties a stored credential to the host it was issued
for, and refuses a `--base-url` naming a different one rather than send
the credential there. `anona login --base-url ...` is how you switch. So
leave the CLI on its default. For your own REST calls, such as the `curl`
below, `api.anonalabs.com` is the default and `memory.anonalabs.com` works
too, and the token is valid on either.

**6. Claim it**

```bash theme={null}
anona login
```

A browser opens on the sign-up page. Create an account there, or follow
**Sign in** if you already have one; either way you come back to the
approval screen. Read the client name, then choose **Allow**. That one approval
claims the profile and signs in both the command line and `anona mcp`.
Over SSH or in a
container, `anona login` prints the URL instead; open it on the machine
running the command, or add `--no-browser` to skip the attempt to open one.

**7. Confirm**

```bash theme={null}
anona status
```

The temporary-profile lines are gone, replaced by the stored sign-in
credential. The dashboard now shows the account with its real balance, and
the confirmation email names the space.

### Reminders on the MCP connection

An agent is told about the deadline by the server, not only by its setup
prompt, so a later session that never saw the prompt still knows:

* The MCP `initialize` reply carries **instructions** naming the deadline and
  saying that `anona login` claims the profile, and that an agent with a shell
  tool can run it itself.
* A tool result carries a second text item, `[Anona notice for the agent]`,
  about once an hour per profile, and every 15 minutes in the last 24 hours.

Both stop once the profile is claimed.

## What claiming does

What happens depends on whether the account you sign in with is new.

**A new account takes over the profile's workspace.** `anona login` attaches it
to the workspace that already holds the agent's memories, and renames that
workspace to the organization name you chose at signup. Nothing is copied.
Afterwards it is an ordinary account, indistinguishable from one that signed up
first.

* **The ceiling rises from 1,000 to 5,000 credits.**
* **Credits already spent carry over.** A profile that used 800 credits has
  4,200 left, not 5,000. The allowance cannot be collected twice by claiming.
* **The memories are the same ones.** Nothing is copied, so nothing is lost or
  duplicated.
* **The temporary token is destroyed.** Whatever the agent was holding stops
  working, and you use the account's own sign-in or an API key from here on.
* **A confirmation email** names the space and your real balance.

### Claiming into an account you already have

Sign in with your existing account and the profile's space is **copied into
it** as a new space. Your account stays where it is.

* **The copy is named after the profile's space.** That is usually `default`,
  and since your account most likely has its own `default`, the copy becomes
  `default-claimed` (then `default-claimed-2`, and so on). The confirmation
  email names it, and `anona spaces list` shows it. Pass that name as the space
  when you want those memories.
* **Your other spaces and your credits do not change.** Copying calls no model,
  so it costs nothing, and the credits the profile spent are not charged to you.
* **Your plan's space limit applies.** If your account already has as many
  spaces as its plan allows, the claim is refused with `claim_space_limit` (HTTP
  409\) and nothing is copied. Delete a space or upgrade, then open the same
  sign-in link again before the 72 hours are up.
* **Webhooks on the profile are not copied.** Set them up again on the new
  space if you want them.

The browser approval says which of the two will happen before you choose Allow.
An account that has already done things (created an API key, recorded usage,
invited a colleague, or subscribed) counts as existing, even if it was created
recently.

## Check the credit ceiling

With the CLI, read it with `anona usage --json`, which uses the stored token
without exposing it. The figures in these replies are illustrative:

```bash theme={null}
anona usage --json
```

Without the CLI, the temporary token can read its own balance:

```bash theme={null}
curl https://api.anonalabs.com/v1/usage/me \
  -H "Authorization: Bearer anona_tmp_YOUR_TOKEN"
```

```json theme={null}
{ "credits_remaining": 989, "credits_limit": 1000, "credits_used": 11, "rate_limit_per_min": 20 }
```

The token is in `~/.anona/credentials.json` under `temp_token`. Treat it like
an API key: anyone holding it can read and write the profile. Past the ceiling, metered calls are
refused in the standard error envelope with a lowercase `code`; see
[error codes](https://docs.memory.anonalabs.com/api-reference/errors.md).

Read it before and after claiming to see the effect. In the first production
run, 11 credits used before the claim read `5000 limit / 11 used / 4989
remaining` after it. The temporary token stops working once claimed, so after
the claim make the same call with an API key from the dashboard.

## Abandoning one

`anona logout` refuses to delete a live unclaimed profile, because the token
exists nowhere else and deleting the file strands the profile and everything in
it until the server removes it:

```bash theme={null}
anona logout          # refused while a live unclaimed profile is stored
anona logout --force  # discards it. This cannot be undone
```

Signing in to a different server with `anona login --base-url ...` also
replaces the stored profile. It prints a note first.

## Failure modes

| You see | Meaning |
| - | - |
| `anona start: Too many temporary profiles from this address today.` | Profile creation is limited to 5 a day per address. Try again tomorrow. |
| `anona start: The server refused to create a profile (404)` | The server has the feature switched off. Use `anona login` instead. |
| `anona start: you are already signed in` | A signed-in credential is stored. Run `anona logout` first if you want a profile. |
| `temp_profile_expired` (401) | The 72 hours have passed. The memories are deleted. |
| `temp_profile_unclaimable` (409) | The profile is already claimed, expired or unknown. Run `anona start` for a new one. |
| `claim_space_limit` (409) | Your account is at its plan's space limit, so the profile's space had nowhere to go. Nothing was claimed. Delete a space or upgrade, then approve again. |
| `claim_unavailable` (503) | The memories could not be copied right now. Nothing was claimed; approve again. |
| `claim_owner_only` (403) | Your organization is org-wide and only an owner or admin can add a space to it. Nothing was claimed; ask one of them, or claim into an account of your own. |

## Related

* [The anona CLI](https://docs.memory.anonalabs.com/cli/overview.md) covers every command, and
  [Sign in & credentials](https://docs.memory.anonalabs.com/cli/sign-in.md) the order credentials are tried in.
* [Self-onboarding prompt](https://docs.memory.anonalabs.com/agents/onboarding-prompt.md) is a prompt that does all
  of this for you, and reports back when it is done.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.