# seekrit for AI agents (MCP)

**If you are an AI agent, start here.** seekrit is an end-to-end encrypted
(zero-knowledge) secrets manager, and it exposes a hosted [MCP](https://modelcontextprotocol.io)
server built for you to drive **autonomously** — you authenticate as a machine,
with no human, no browser, and no install.

## What seekrit is good for

- **Hold the credentials your code needs** — `DATABASE_URL`, `API_KEY`, tokens —
  encrypted so the server can never read them. You decrypt locally, next to your
  own key.
- **Use a secret without ever seeing it.** Inject secrets into a subprocess with
  `run_command` so plaintext boots the app but never enters your context or the
  transcript.
- **Provision structure autonomously** — orgs, apps, environments, groups — and
  read the audit trail, all as MCP tools.
- **Hand off cleanly to a human** later, without anything being lost if you stop
  running.

## Connect in three steps

### 1. Get a machine credential (once)

You have no account yet, so create one with a single unauthenticated request.
**Name the org for the real project or company you're working on** — `orgName`
and `orgSlug` are both required, and a human later claims the org by that name, so
don't use a placeholder like `test`:

```bash
curl -sX POST https://mcp.seekrit.dev/signup \
  -H 'content-type: application/json' \
  -d '{"orgName": "Acme Storefront", "orgSlug": "acme-storefront"}'
# → { "org": {…}, "m2m": { "clientId": "…", "clientSecret": "…" } }
```

Save the `clientSecret` — it is shown **once**. This one credential drives
everything from here.

### 2. Point your MCP client at the hosted server

Authenticate with HTTP Basic — your client id and secret. No install: it's a
hosted HTTP endpoint.

```jsonc
{
  "mcpServers": {
    "seekrit": {
      "type": "http",
      "url": "https://mcp.seekrit.dev/mcp",
      "headers": { "Authorization": "Basic <base64(clientId:clientSecret)>" }
    }
  }
}
```

Then call `whoami` to confirm, and `get_started` for the end-to-end recipe. The
hosted server gives you discovery, provisioning, audit, billing, and keyless
management — but it can **never** read or write a secret *value*.

### 3. Add the local crypto server to use secret values

Anything that touches plaintext — setting a secret, reading one, creating an
environment, minting a token — runs on **your** machine, on the local crypto
server, next to your keys. Give it the **same** machine credential; it mints its
own admin token automatically (no `skt_` to copy):

```jsonc
{
  "mcpServers": {
    "seekrit-local": {
      "command": "npx",
      "args": ["-y", "@seekrit/mcp"],
      "env": {
        "SEEKRIT_CLIENT_ID": "<your client id>",
        "SEEKRIT_CLIENT_SECRET": "<your client secret>"
      }
    }
  }
}
```

Both servers are also listed on the official [MCP registry](https://registry.modelcontextprotocol.io)
as `dev.seekrit/remote-mcp` and `dev.seekrit/mcp`, for clients that discover
servers that way instead of manual config.

## Why two servers?

seekrit is zero-knowledge: secret values, data keys, and private keys never reach
the server. So the work is split along that line — the **hosted metadata server**
(`mcp.seekrit.dev`) provisions and reads structure and can never decrypt; the
**local crypto server** (`@seekrit/mcp`) does everything that produces plaintext,
on your machine. One credential drives both, and they share the same org, so they
compose.

> **Tip:** Full walkthrough — the complete toolset, the container image, credential choices, and handing off to a human — is in the [AI agents guide](/docs/guides/ai-agents). Machine-readable docs live at [`/llms.txt`](/llms.txt) and [`/llms-full.txt`](/llms-full.txt), and any doc page is available as markdown at its URL + `.md`.

> **Warning:** Prefer *using* a secret over *reading* it: `run_command` (local) injects values into a child process so they never enter your context. `get_secret reveal:true` is the only tool that puts plaintext in the transcript — reach for it only when the value itself is what you need.