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

> ## Agent Instructions
> To act on Atlan objects, use the Atlan MCP server at https://api.atlan.com/mcp or the SDK. To install or publish skills from a terminal, use the `brain` CLI; `brain --map json` prints its command map. The `atlanai` CLI is deprecated. Run a read-only identity check before any write.
> The docs MCP server at /mcp searches these docs only. It cannot read or change Atlan objects.
> SDK packages: Python `atlanai` (PyPI) and TypeScript `@atlanai/sdk` (npm). Show Python first, then TypeScript.
> These docs cover Atlan Agent Registry, Atlan's hosted product. The open-source agent registry specification and its CLI (`brain`) are documented, released and maintained in their own repository; /open-source on this site links to it. Answer general specification or `brain` command questions from the project's own docs, and use these docs only for Atlan-specific setup such as the Atlan adapter, sign-in and workspaces.

# Move to brain from atlanai

> What Atlan Desktop moves for you, the steps to move off the deprecated atlanai CLI if you use only the command line, and which brain command replaces each atlanai command.

For Atlan, `brain`, the open-source Agent Registry CLI, with the
[Atlan adapter](/tools/brain/references/atlan-adapter) replaces the deprecated
**`atlanai`** CLI. `atlanai` published skills, read registry objects, and
captured traces through hooks in Claude Code and Codex.

If you used **`registry`**, the earlier package manager that `brain` grew out
of, Atlan Desktop moves that setup for you too.

How you move depends on whether you use Atlan Desktop.

| You use | From `atlanai` | From `registry` |
| - | - | - |
| Atlan Desktop | Turned off for you | Moved for you |
| The command line only | **Not moved.** Follow the steps below. | See the [open-source project](/open-source#where-to-find-what) |

## If you use Atlan Desktop

Atlan Desktop does the move when it starts. You don't run anything.

**From `registry`** (macOS and Linux). The app stops the old CLI's background
service and moves your setup to `brain`: your settings, the registries you
declared, what you installed for your user, what you installed in each project
the old CLI's jobs kept in sync, your adapters, and your jobs. It then removes the old CLI's files from `~/.registry`, keeping
a backup under `~/.brain/handoff-backup/`. If the move fails, the app tries
again later, and doesn't start the `brain` background service until the move
is done.

**From `atlanai`**. After you sign in, and once `brain` is signed in to all
your organizations, the app turns off `atlanai` in your coding agents:

* It stops the `atlanai` background service, and removes its macOS login item
  if an older version added one.
* It uninstalls the Atlan plugins that `atlanai` added to Claude Code, and
  removes the Atlan plugin marketplaces they came from.
* It removes `atlanai` hooks from `~/.claude/settings.json`, and saves the
  previous file as `settings.json.pre-registry`.
* In Codex, it removes the Atlan plugin marketplaces, any Atlan plugins left
  behind, and `atlanai` hooks in `~/.codex/hooks.json`. It saves the previous
  hooks file as `hooks.json.pre-registry`.

It leaves the `~/.atlanai` folder in place, including `~/.atlanai/auth.json`,
which Atlan Desktop uses for your sign-in. It doesn't move skills you
installed with `atlanai skill install` or `atlanai skill pull`. Atlan Desktop
installs your organization's skills for your user on its own; to install one
into a project, use `brain add`.

## If you use the command line only: from registry

Moving a `registry` setup to `brain` is covered by the
[open-source project](/open-source#where-to-find-what). Tokens stored in your
OS keychain don't carry over, so sign in to Atlan again as shown in
[Use brain with Atlan](/tools/brain/how-tos/use-with-atlan#3-sign-in).

## If you use the command line only: from atlanai

Nothing moves you off `atlanai` automatically. Until you do these steps,
`atlanai` keeps capturing sessions through its hooks and keeps updating
itself.

<Steps>
  <Step title="Set up brain">
    Install `brain` and the Atlan adapter and sign in, as described in
    [Use brain with Atlan](/tools/brain/how-tos/use-with-atlan). Do this
    before you remove `atlanai`: while you're still signed in to `atlanai`,
    you can pass its token to `brain`:

    ```bash theme={null}
    atlanai auth token | brain auth login atlan --source https://api.atlan.com --token-stdin
    ```

    That token lasts only as long as the `atlanai` session's current token,
    and `brain` cannot refresh it. `brain` has no browser sign-in yet.
  </Step>

  <Step title="Install your skills again">
    `brain` doesn't read `.atlan/package.json` or the folders `atlanai skill pull`
    wrote. In each project, install the skills you need:

    ```bash theme={null}
    brain registry show atlan
    brain add atlan/<workspace>/skill/<skill-name>
    ```
  </Step>

  <Step title="Capture traces with brain">
    If you used `atlanai` to capture sessions, add a `brain` traces job:

    ```bash theme={null}
    brain job add --traces --account atlan
    ```

    See [Capture traces](/tools/brain/how-tos/capture-traces).
  </Step>

  <Step title="Remove the atlanai hooks">
    ```bash theme={null}
    atlanai trace integration uninstall claude codex
    ```

    This removes the hooks `atlanai` wrote to `~/.claude/settings.json` and
    `~/.codex/hooks.json`. It asks the `atlanai` background service to do it.
    If it says no daemon is running, run `atlanai daemon start` and try again.
  </Step>

  <Step title="Remove the Atlan plugins from Claude Code">
    List your plugins:

    ```bash theme={null}
    claude plugin list
    ```

    Uninstall `atlanai@atlanai`, `atlan-claude-plugin@atlan`, and any plugin
    from an Atlan marketplace, then remove that marketplace. An Atlan
    marketplace is one whose source in
    `~/.claude/plugins/known_marketplaces.json` is
    `https://api.atlan.com/marketplace.git` or another Atlan address.

    ```bash theme={null}
    claude plugin uninstall <plugin>@<marketplace>
    claude plugin marketplace remove <marketplace>
    ```

    Remove a marketplace only after every plugin from it is gone.
  </Step>

  <Step title="Remove the Atlan marketplaces from Codex">
    For each Atlan marketplace in `~/.codex/config.toml`:

    ```bash theme={null}
    codex plugin marketplace remove <marketplace>
    ```

    Codex keeps a removed marketplace's plugins. Remove any that are left:

    ```bash theme={null}
    codex plugin remove <plugin>@<marketplace>
    ```
  </Step>

  <Step title="Stop the atlanai background service">
    ```bash theme={null}
    atlanai daemon stop
    ```

    Stop it last: until the plugins and hooks are gone, a coding-agent session
    can start it again. On macOS, if `~/Library/LaunchAgents/Atlan.plist`
    exists and runs `atlanai`, an older version added it as a login item.
    Unload and delete it:

    ```bash theme={null}
    launchctl bootout gui/$(id -u) ~/Library/LaunchAgents/Atlan.plist
    rm ~/Library/LaunchAgents/Atlan.plist
    ```
  </Step>
</Steps>

If you added the pre-push publishing hook with `atlanai skill hooks install`,
run `atlanai skill hooks uninstall` in each of those repositories.

Atlan Desktop leaves `~/.atlanai` in place, and you can too. Nothing runs
from it after these steps.

## Command map: atlanai

"Not in brain yet" means neither `brain` nor the Atlan adapter has the
feature today. Where the API has it, the last column links to the SDK.

| `atlanai` | `brain` | Otherwise |
| - | - | - |
| `auth login` | `brain auth login <registry> --source https://api.atlan.com --token-stdin`. No browser sign-in yet. | |
| `auth status` | `brain auth list` | |
| `auth logout` | `brain auth logout <registry>` | |
| `auth token` | Not in brain yet | |
| `ATLANAI_TOKEN` | `REGISTRY_TOKEN_<NAME>`, or `ATLAN_REGISTRY_TOKEN` at sign-in | |
| `context use`, `ATLANAI_WORKSPACE`, `--workspace` | Name the workspace in the address: `atlan/<workspace>` | |
| `config set telemetry.enabled` | `brain telemetry off` | |
| `doctor` | `brain doctor` | |
| `logs` | `brain logs` | |
| `version` | `brain --version`, and `brain adapter list` for the adapter | |
| `completion` | Not in brain yet | |
| `--map` | `brain --map` | |
| `api` | Not in brain yet | [SDK](/tools/sdk/overview) or any HTTP client |
| `search` | Not in brain | [SDK search](/tools/sdk/references/operations/root) |
| `workspace list`, `workspace get` | Not in brain | [SDK workspaces](/tools/sdk/references/operations/workspaces) |
| `file …` | Not in brain | [SDK files](/tools/sdk/references/operations/files) |
| `agent …` | Not in brain. `brain agent new` only creates a local file. | [SDK agents](/tools/sdk/references/operations/agents) |
| `harness …` | Not in brain | [SDK harnesses](/tools/sdk/references/operations/harnesses) |
| `skill list` | `brain registry show <registry>` | [SDK skills](/tools/sdk/references/operations/skills) |
| `skill get` | `brain show <registry>/<workspace>/skill/<name>` | [SDK skills](/tools/sdk/references/operations/skills) |
| `skill validate` | `brain publish <folder> --to <registry>/<workspace> --dry-run` | |
| `skill push` | `brain publish <folder> --to <registry>/<workspace>` | |
| `skill pull`, `skill install` | `brain add <registry>/<workspace>/skill/<name>`. It installs into your coding agents, not into a folder you choose. | |
| `skill link`, `skill unlink` | Not needed: `brain publish` adds a version to the skill with the same name in that workspace. To publish a folder whenever it changes, use `brain job add --watch <folder> --to <registry>/<workspace>`. | |
| `skill publish` | `brain publish <paths> --to <registry>/<workspace> --changed-since <commit>`. No branch guard, `publishConfig`, `--prune`, or publishing to several workspaces at once yet. | |
| `skill delete` | No command. `brain sync --delete on` archives a skill you installed from Atlan and then deleted here. | [SDK skills](/tools/sdk/references/operations/skills): archive |
| `skill versions`, `skill runs`, `skill approve` | Not in brain yet | |
| `skill rollback` | Not in brain yet | |
| `skill hooks install` | Not in brain yet | |
| `trace integration install` | `brain job add --traces --account <registry>`. brain reads transcripts and installs no hooks. | |
| `trace session list` | `brain trace list` | |
| `trace import`, `trace reconcile` | `brain trace export --account <registry>` | |
| `trace config set capture.store-content false` | `--content drop` on `brain trace export` or `brain job add --traces` | |
| `trace outbox` | `brain job runs` and `brain job retry` | |
| `trace runtime rollback` | `brain self update --rollback` | |
| `trace data`, `trace support bundle` | Not in brain yet | |
| `daemon stop` | `brain daemon stop` | |

The Atlan SkillSync GitHub Action publishes skills with `atlanai`. Replace it
with the `brain` workflow in
[Sync skills from GitHub](/registry/skills/how-tos/sync-from-github).

## Related

* [Use brain with Atlan](/tools/brain/how-tos/use-with-atlan)
* [Use the open-source CLI with Atlan](/tools/brain)
* [Errors with Atlan](/tools/brain/troubleshooting/atlan-errors)


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