Skip to main content
An MCP server gives an agent the ability to remember. It does not give it the habit. You still end up typing “remember that” and “what did we decide about the deploy” every session. Agent Skills close that gap. A skill is a Markdown file the agent loads when its description matches what you are doing, so recall at the start of a task and recording at the end become part of how the agent works.

​
Install

The installer detects the agents already on your machine, copies the skills in, stores your key at ~/.anona/config.env with mode 600, and registers the MCP server with Claude Code when the claude CLI is on your PATH. It edits no shell profile and writes nothing outside the directories it prints.
Skills load at session start. Restart your agent once after installing, or the skill is on disk and invisible.

​
The two skills

anona-memory

The agent’s own memory. Recalls what is already known before a task, records what the task settled after it.

anona-memory-sdk

Building on Anona. The SDK and API surface, scoping rules, error codes and framework adapters, so generated code compiles the first time.
Install one instead of both with --skill:

​
Options

An existing install is moved under ~/.anona/backups/ rather than deleted, and deliberately not left beside the skill: an agent reads every directory under skills/, so a backup parked there would load as a second skill claiming the same name.

​
How the skill reaches your memory

Four ways, tried in order. You only need one.
1

MCP tools

If the host exposes record, retrieve, reason and list_spaces, the skill uses them and there is nothing to configure.
See MCP for OAuth, the local stdio server, Hermes and OpenClaw.
2

The anona CLI

Otherwise, if the anona CLI is installed (pip anona 0.24.0 or later), the skill runs anona status once, then anona retrieve, anona record and anona reason with --json, and branches on the exit code. The CLI finds its own credential: an API key (--api-key, ANONA_API_KEY, or ~/.anona/config.env), the command-line login from anona login, or a temporary profile from anona start. It never uses the MCP login, so a machine signed in for MCP only exits 4 here and the skill moves on.
3

REST with curl

Otherwise the skill reads ANONA_API_KEY from the environment or from ~/.anona/config.env and calls https://api.anonalabs.com directly. This is what makes the skill work in a harness with no MCP support and no Python.
4

Neither

If anona or uvx is available, the skill may run anona start for a temporary profile and tell you so in one line; you keep it with anona login. Otherwise it says once that memory is not configured and does the task without it. A memory layer that blocks the work is worse than no memory layer.
MCP OAuth sign-in needs no API key. An organization that has never created one works from its first tool call. If you see 403 no_api_key, that is a fault on our side, not a missing step on yours; the one case where it is intended is an organization that revoked all of its keys.

​
Which space

The skill picks one per session, in this order:
  1. ANONA_SPACE_ID, set by --space or in your environment.
  2. The git repository name, lowercased, when working in a repo.
  3. default.
A write creates the space. A read does not, so 404 space_not_found on a space nothing has been written to yet means empty, not broken.
Serving several people through one space? The skill passes user_id when you give it one, and the match is strict in both directions: a scoped read never returns an unscoped memory. See Scoping.

​
What gets recorded

Preferences, decisions and their reasons, fixes that cost time, constraints the code does not state, and outcomes. One fact per memory. Not recorded: secrets, anything already in the repository, narration of the session, or anything still a hypothesis. The skill carries the judgment call and worked examples of both sides.

​
Compaction

Compacting a conversation swaps it for a summary, and whatever the summary drops is gone. The skill treats that as a deadline: what the session settled goes to Anona before it can be lost.
  • Before. Tell the agent you are about to compact and it records what the session settled first, then says how many memories it wrote.
  • After. When a conversation resumes from a summary, the agent records the durable facts in it before going back to the task.
It sends facts, one per memory and into the session’s usual space, never the transcript or the summary itself. Over REST each one carries "trigger": "compaction" in metadata; the MCP record tool has no metadata field, so there it goes without the marker. The same rules apply: no secrets, nothing already in the repository, nothing still a hypothesis.

​
The compaction hook

Claude Code compacts without giving the agent a turn first, by /compact or automatically when the context fills, so skill instructions alone cannot run the “before” half: it happens only when you ask for it. The “after” half is what a hook makes reliable. A Claude Code hook is a command the client runs on a lifecycle event. Anona uses one: SessionStart with the compact matcher, which fires once the summary is in place. Its output is added to the agent’s context, telling it to record what the summary kept before resuming. The hook only prints. It makes no network call and holds no key, so it cannot slow a session down or fail one, and the recording itself goes through the same MCP tools, CLI or curl fallback as every other write. Adding it by hand. Put this in ~/.claude/settings.json, or in .claude/settings.json for one project:
Run /hooks in Claude Code to confirm it is registered. Turning it off. For the plugin, disable it under /plugin, which also unloads the skills. Claude Code has no switch for one plugin’s hooks: "disableAllHooks": true in settings turns off every hook you have, not only this one. If you added the hook by hand, delete the entry. Either way the skill still records before a compaction you announce. Checking it works. Compact a session in which something was decided. Before the next task resumes the agent should make one record call per durable fact, into the session’s usual space, and nothing at all when the session settled nothing.

​
Claude Desktop and claude.ai

Those two do not read a skills directory. They take a ZIP upload under Customize > Skills, so build one:
That writes anona-memory.zip and anona-memory-sdk.zip into the current directory, with the skill folder as the archive root, which is what the upload expects. Both skills stay inside the caps that surface enforces on name and description, 64 and 200 characters. Then give them tools. There is no shell there, so the CLI and curl fallbacks cannot run: add Anona as a custom connector under Settings > Connectors.
Sign in with OAuth when prompted. See MCP for the same flow in other clients.
The Claude Code that runs inside Claude Desktop is a different surface, and it reads ~/.claude/skills/ normally. The installer at the top of this page already covers it. The ZIP is only for the chat surface.

​
Supported agents

The installer knows Claude Code, Codex, OpenCode, Cursor, Hermes and OpenClaw (into ~/.openclaw/skills, or $OPENCLAW_STATE_DIR/skills if you moved it), and takes --dir for anything else. The community npx skills CLI covers 75+ harnesses from the same repository:

​
Source

The skills live in skills/ in the SDK repository. Read them before you install them; they are four Markdown files and a shell script.

​
Next steps

MCP

The transport the skill prefers, with OAuth and stdio.

Python SDK

The programmatic client the second skill documents.