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

# Agent Skills

> Install Anona into Claude Code, Codex, Hermes and other agents so they remember, without being told to.

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

<CodeGroup>
  ```bash Installer theme={null}
  curl -fsSL https://raw.githubusercontent.com/anonalabs/Anona-Memory-SDK/main/skills/install.sh | bash
  ```

  ```bash npx skills theme={null}
  npx skills add anonalabs/Anona-Memory-SDK
  ```

  ```bash Claude Code plugin theme={null}
  /plugin marketplace add anonalabs/Anona-Memory-SDK
  /plugin install anona-memory@anona
  ```
</CodeGroup>

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.

<Note>
  Skills load at session start. Restart your agent once after installing, or the
  skill is on disk and invisible.
</Note>

## The two skills

<CardGroup cols={2}>
  <Card title="anona-memory" icon="brain">
    The agent's own memory. Recalls what is already known before a task, records
    what the task settled after it.
  </Card>

  <Card title="anona-memory-sdk" icon="code">
    Building on Anona. The SDK and API surface, scoping rules, error codes and
    framework adapters, so generated code compiles the first time.
  </Card>
</CardGroup>

Install one instead of both with `--skill`:

```bash theme={null}
install.sh --skill anona-memory
```

## Options

```bash theme={null}
install.sh --app claude --api-key anona_live_... --space my-project
install.sh --project          # into ./.claude/skills rather than ~/.claude/skills
install.sh --dir /path/to/skills
install.sh --zip                # build uploadable .zip files, see below
install.sh --no-mcp
install.sh --uninstall
install.sh --help
```

| Option              | Effect                                                                                                                           |
| ------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `--app <name\|all>` | `claude`, `codex`, `opencode`, `cursor`, `hermes`, or `all`. Defaults to every one already present.                              |
| `--skill <name>`    | `anona-memory` or `anona-memory-sdk`. Repeatable. Defaults to both.                                                              |
| `--project`         | Installs into `./.claude/skills`, so the skill ships with the repository.                                                        |
| `--dir <path>`      | Installs into one directory and nowhere else. Use this for a harness the installer does not know.                                |
| `--api-key <key>`   | Verified against the API before it is written. Prompted for if omitted and a terminal is attached.                               |
| `--space <id>`      | The default space the skill records into.                                                                                        |
| `--zip [dir]`       | Builds one `.zip` per skill instead of installing, for upload to Claude Desktop or claude.ai. Defaults to the current directory. |
| `--no-mcp`          | Skips MCP registration and prints the config snippets instead.                                                                   |
| `--uninstall`       | Removes the skills. Leaves `~/.anona/config.env` alone.                                                                          |

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

Three transports, tried in order. You only need one.

<Steps>
  <Step title="MCP tools">
    If the host exposes `record`, `retrieve`, `reason` and `list_spaces`, the
    skill uses them and there is nothing to configure.

    ```bash theme={null}
    claude mcp add --transport http anona https://memory.anonalabs.com/mcp \
      --header "Authorization: Bearer $ANONA_API_KEY"
    ```

    See [MCP](/mcp-integration) for OAuth, the local stdio server, and Hermes.
  </Step>

  <Step title="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 at all.
  </Step>

  <Step title="Neither">
    The skill says so once, in one line, and does the task without memory. A
    memory layer that blocks the work is worse than no memory layer.
  </Step>
</Steps>

<Warning>
  Your organization needs at least one API key for MCP OAuth sign-in to work.
  Signing in authenticates you, but the service still reaches memory through one
  of your organization's keys, so an organization that has never created one gets
  `403 no_api_key` on its first tool call. Creating a key once in the dashboard is
  enough; it does not have to go in any config file.
</Warning>

## 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 `space_not_found` on a space
nothing has been written to yet means empty, not broken.

<Note>
  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](/guides/scoping-multi-tenant).
</Note>

## 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.

## Claude Desktop and claude.ai

Those two do not read a skills directory. They take a **ZIP upload** under
Customize > Skills, so build one:

```bash theme={null}
curl -fsSL https://raw.githubusercontent.com/anonalabs/Anona-Memory-SDK/main/skills/install.sh | bash -s -- --zip
```

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 `curl` fallback cannot
run: add Anona as a **custom connector** under Settings > Connectors.

```
https://memory.anonalabs.com/mcp
```

Sign in with OAuth when prompted. See [MCP](/mcp-integration) for the same flow
in other clients.

<Note>
  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.
</Note>

## Supported agents

| Surface                                             | Skills                                             | Tools                              |
| --------------------------------------------------- | -------------------------------------------------- | ---------------------------------- |
| Claude Code, in a terminal or inside Claude Desktop | Installer, `npx skills`, or the plugin marketplace | MCP server, or the `curl` fallback |
| Codex, OpenCode, Cursor, Hermes                     | Installer or `npx skills`                          | MCP server, or the `curl` fallback |
| Claude Desktop chat, claude.ai                      | `--zip`, then upload under Customize > Skills      | Custom connector only              |

The installer knows Claude Code, Codex, OpenCode, Cursor and Hermes, and takes
`--dir` for anything else. The community `npx skills` CLI covers 75+ harnesses
from the same repository:

```bash theme={null}
npx skills add anonalabs/Anona-Memory-SDK --agent codex --global
```

## Source

The skills live in [`skills/`](https://github.com/anonalabs/Anona-Memory-SDK/tree/main/skills)
in the SDK repository. Read them before you install them; they are four Markdown
files and a shell script.

## Next steps

<CardGroup cols={2}>
  <Card title="MCP" icon="plug" href="/mcp-integration">
    The transport the skill prefers, with OAuth and stdio.
  </Card>

  <Card title="Python SDK" icon="python" href="/sdk/python">
    The programmatic client the second skill documents.
  </Card>
</CardGroup>