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

# MCP buttons

> Freeze an MCP tool invocation as a deterministic, reusable button.

MCP and Buttons meet in two directions. One ships today; the other is planned.

* **Buttons → MCP (shipped):** `buttons mcp` runs Buttons *as* an MCP server, so any agent can list and press your buttons as deterministic tools.
* **MCP → Buttons (planned):** capture an agent's exploration of an MCP server — list tools, find the right tool and parameter shape, confirm the call works — and freeze that known-good invocation as a button. This is the page's namesake feature and is **not built yet**.

## What ships today: expose buttons as MCP tools

`buttons mcp` runs an MCP server over stdio that exposes a small meta-tool surface to any MCP client (Claude Desktop, Cursor, etc.):

* `buttons_list` — list buttons available as tools
* `buttons_press` — press a button by name with args
* `buttons_inspect` — read a button's spec
* `buttons_create` — **only** when started with `--allow-create` (off by default)

Point an MCP client at it:

```json theme={null}
{
  "mcpServers": {
    "buttons": { "command": "buttons", "args": ["mcp"] }
  }
}
```

Add `"--allow-create"` to `args` to also expose `buttons_create`.

Only buttons that opt in are visible or pressable: set `"mcp_enabled": true` in the button's `button.json`. The server is rate-limited (10 calls/min, 1 concurrent, 120s cap per call) so an agent can't hammer it.

This is the inverse of the planned "freeze an MCP tool" flow: instead of wrapping someone else's MCP tool as a button, you take any button you already have — shell, HTTP, anything — mark it `mcp_enabled`, and it becomes a scoped, deterministic tool an agent can call without re-discovering anything.

## What's planned: MCP → Buttons

<Note>
  The MCP-tool-to-button import is **not implemented yet**. The intended entry point is `buttons import mcp <server>`, which today returns an `IMPORT_ERROR` ("not implemented yet"). Only `import code`, `import skill`, and `import url` create buttons right now. There is no `buttons create --mcp` flag.
</Note>

When it lands, the idea is to save a frozen MCP invocation as a button so future presses skip the exploration entirely and go straight to the known-good call:

```bash theme={null}
# Planned — not yet implemented
buttons import mcp slack
```

The same button would then work in two contexts:

* An agent reviewing the button sees it's a safe, scoped call — no re-discovery of the MCP server required
* A deterministic workflow (drawer, cron, webhook) can press it without involving an LLM at all — the MCP call is already parameterized and approved

### Why this matters

Without this, every agent session has to rediscover the same tools: list servers, list tools, read schemas, guess parameters, verify the call. Freezing that one-time exploration into a button turns it into a reusable asset — and, pressed as JSON, returns the tool's structured response in the same envelope as every other button.


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