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

# Advanced

> Use a personal API key and a local agent to tune your workspace and notifications.

Use a personal API key when you want a local agent, such as Codex or Claude
Code, to help configure Ando as you. This is best for personal setup work:
organizing your sidebar, tuning notifications, checking delivery readiness, and
reviewing your own workspace setup.

<Tip>
  If you are truly next-level lazy, send this page to your agent and ask it to
  walk you through the setup. It should still read first, explain what it can
  change, and wait for your approval before writing anything.
</Tip>

<Note>
  A personal API key acts as you and inherits your workspace access. Create a
  separate key for each local client, keep it private, and revoke it when you no
  longer use that client.
</Note>

## Create a personal API key

1. Open **Studio** → **API & Webhooks** → **API keys**.
2. Create a **Personal key** for your local client.
3. Expand **Customize permissions** before saving.
4. Keep the ordinary read permissions the client needs.
5. Enable **Profile write** if you want the client to update notification
   settings for you.

Personal keys are described in [Developers → Overview](/developers/overview#choose-an-identity).
The MCP setup page also has client-specific setup for
[Codex CLI](/docs/ando-mcp#codex-cli) and [Claude Code](/docs/ando-mcp#claude-code).

## Connect your local agent

Add Ando MCP to the local client with this server URL:

```text theme={"system"}
https://mcp.ando.so/mcp
```

Pass your personal API key as the bearer token. After connecting, ask the local
agent to identify what tools are available before making changes. The available
tool list is the source of truth for what that client can read or update.

Try a prompt like this:

```text theme={"system"}
Use Ando MCP as my personal setup assistant.
First list the Ando tools available to you and explain what you can safely
read or change for me. Do not change anything until I approve the exact plan.
```

This is also a good time to tune the local agent's own review settings. Ask it
to explain when it can make changes automatically, when it will ask before
editing or running commands, and how its auto-review or approval settings affect
your Ando setup work.

```text theme={"system"}
Review your Codex or Claude auto-review and approval settings for this project.
Explain what you can do automatically, what requires my approval, and what you
recommend changing before you help configure Ando.

Do not change those settings until I approve the exact recommendation.
```

## Organize your sidebar

Your sidebar should match how you work, not the order channels happened to be
created. Ask the local agent to help you decide what should be pinned, grouped,
muted, or left in the regular conversation list.

Try a prompt like this:

```text theme={"system"}
Help me clean up my Ando sidebar.
Look for conversations I use often, conversations I only need for reference,
and noisy channels that should stay available without demanding attention.

Propose a sidebar setup with:
- pinned or high-priority conversations,
- channels that should stay unpinned,
- conversations whose notification level should change,
- anything you cannot verify from your available tools.

Do not change anything until I approve the exact changes.
```

If your local agent has tools for sidebar changes, have it apply only the
approved changes. If it does not, use its plan as a checklist while you update
the sidebar in Ando.

## Tune notifications

Local MCP clients can read and update your own notification settings with a
personal API key. Enable **Profile write** on the key if you want the client to
save changes.

Ask the client to call `get_notification_settings` before writing. It can use
`get_notification_delivery_readiness` to find setup blockers and
`explain_notification_behavior` to explain whether a specific kind of message
would notify you.

Try a prompt like this:

```text theme={"system"}
Review my Ando notification setup.
Call get_notification_settings first and summarize my desktop and mobile
defaults, quiet hours, and conversation exceptions.

Then propose a setup that keeps DMs and mentions visible, quiets noisy channels,
and preserves alerts for work I directly own. Do not update anything until I
approve the exact changes. If I approve, call update_notification_settings with
the revision from the settings readback.
```

For more detail, see [Notifications](/docs/notifications#configure-notifications-from-local-codex-or-claude).

## Use miniapps with your agent

Miniapps are small native Ando surfaces an agent can post when a normal message
would be clumsy. They are useful for choices, approvals, lightweight trackers,
and repeatable workflows that should stay in the conversation.

Ask your local agent to use a miniapp when you want to review or change
structured information without switching tools. For example, it can ask an
explicit question, propose a poll, update a CRM-style list, or keep a small
shared record current.

Try a prompt like this:

```text theme={"system"}
When you need my input in Ando, prefer a miniapp over a long message if the
answer is a choice, approval, or small structured edit.

Use $ando.question for explicit decisions. If a configured miniapp already
exists for the workflow, read its command contract first and explain what it
will post before creating it. If you are changing an existing miniapp, update
the same instance instead of creating a replacement.
```

Miniapps still follow Ando permissions. Posting one does not grant your agent
new workspace access, connect an account, or approve a provider action for you.
When a miniapp needs connected-app access, Ando asks a person to choose the
account and consent to the requested operations.

For the agent-facing details, see [Miniapps](/docs/ando-mcp/publish-miniapps).


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