# Install MissingManual

Install one skill, save a card once, and ask your agent to research. No signup, password, dashboard, or API key.

## Give this to your agent

> Set up MissingManual — a deep-research service I use. Run `npx -y missingmanual setup --client claude-code --email [my email]` (or `codex` / `cursor` for those agents). Codex installs once for this machine; Claude Code and Cursor install in this project. Docs: https://missingmanual.ai/install.md

## Two ways to install

- [The `missingmanual` package](#the-missingmanual-package) — the default for Codex CLI, Claude Code, and Cursor. Save a card once; later requests run without another website visit and results land in your repository.
- [The remote MCP server](#remote-mcp-endpoint) — for any Streamable HTTP MCP client that prefers a separate Stripe checkout for every run.

Both paths reach the same service at the same price. Enrollment is opt-in and is never a prerequisite for anonymous checkout.

## The missingmanual package

Run one command from the repository you want your agent to research:

```bash
npx -y missingmanual setup --client codex --email you@example.com
```

Replace `codex` with `claude-code` or `cursor`. The email is required to save a card. MissingManual uses it only to reach you when a future payment needs your attention.

The command installs the local MCP server and the single `missingmanual` skill, then prints a private Stripe link. Your agent hands you the link; you open it and save your card yourself. Then run the same setup command again; it finishes enrollment without creating a second account or charge. Restart your coding agent, then say:

> Use missingmanual to research [your question].

That is the entire routine. Your agent chooses papers or a guide, waits for the checked result, and saves it into your repository. Tell it `links only` or `no file changes` when you do not want local files.

Codex installation is machine-wide: it writes `~/.codex/config.toml` and `~/.codex/skills/missingmanual/SKILL.md`, so every Codex project uses the enrolled local adapter. It replaces the legacy direct-remote `missing-manual` entry, because that entry cannot access your local billing credential and falls back to per-run Checkout. Claude Code and Cursor remain project-scoped, writing `.mcp.json` / `.claude/skills/missingmanual/SKILL.md` and `.cursor/mcp.json` / `.cursor/skills/missingmanual/SKILL.md` respectively. Every changed config is backed up; repeated setup does not duplicate entries.

## Package commands

- `missingmanual setup --client codex|claude-code|cursor --email you@example.com` — install the server and skill, then start or finish one-time card enrollment.
- `missingmanual install --client codex|claude-code|cursor` — add the server and skill without enrolling a card.
- `missingmanual uninstall --client codex|claude-code|cursor` — remove that entry, and the installed skill if you have not edited it. It deletes no local research and no saved credential.
- `missingmanual revoke` — end this installation's authority to bill and forget its credential. Your saved card stays at Stripe; `missingmanual enroll` starts again.
- `missingmanual doctor` — report, per client, whether the server and skill are installed, and whether this machine holds an active enrollment. `--client` narrows it to one.
- `missingmanual enroll` — start card enrollment. `--email <address>` is required; `--label <name>` is optional.
- `missingmanual enroll-poll` — finish enrollment after the card is saved.
- `missingmanual serve` — run the local stdio MCP server. Your client runs this for you; you do not run it by hand.

## Enroll a card once

Enrollment is optional. It is not a signup: no password, no dashboard, nothing to log into. It saves a card with Stripe and issues a credential scoped to that one installation, so later research requests from you or your agent bill without a checkout page each time.

```bash
missingmanual enroll --email you@example.com
# open the printed link, save a card, then:
missingmanual enroll-poll
```

The `--email` address is required and used only to reach you when a charge needs your action. Consent at enrollment covers future research that *you or your coding agent* starts from this installation, at the same **$25** per-job ceiling. Your research request, including any code excerpts your agent includes in the brief, is sent to third-party model providers to perform the research. Revoke at any time with `missingmanual revoke`: it ends this installation's authority to bill and forgets the credential locally. Your saved card is untouched at Stripe. `missingmanual uninstall` only removes the MCP entry from the selected client; it deliberately does not revoke, and it tells you so if you are still enrolled.

## When a charge needs you

If an automatic charge needs a human — the bank asks for authentication, or the card is declined — the tool call that hit the problem fails with a reason and an actionable URL. Open that URL to resolve it. No research runs on that job until it is resolved, and nothing is captured.

MissingManual also emails the address you enrolled with. Email is best-effort. It is never guaranteed to be received, so treat the URL returned to the tool call as the reliable channel.

## What the package saves

The local server adds `save_guide` and `save_papers` alongside the forwarded research tools. They detect the guides and papers convention your repo already uses, falling back to `docs/research/{guides,papers}` when there is none. Writes are atomic, never silently overwrite different content at the same path, and add provenance and an index entry. `save_papers` downloads full text and converts ordinary text PDFs to Markdown. A source is reported as `blocked` only when it cannot be downloaded, safely converted, or contains no extractable text. If you ask for links only, or for no file changes, nothing is written.

The package never returns a raw job id or capability to your agent. It hands back an opaque local handle, and the same handle always resumes the same paid job.

## Remote MCP endpoint

Available today, with no package and no enrollment. Anonymous, one Stripe checkout per run.

```text
https://missingmanual.ai/mcp
```

Use a remote MCP connection with **Streamable HTTP** transport. No authorization header is needed for discovery. In other compatible clients, add this URL using their remote MCP server settings; configuration formats differ. Do not fetch `/mcp` as a document.

## Claude Code (remote MCP)

```bash
claude mcp add --transport http missing-manual https://missingmanual.ai/mcp
```

See the [Claude Code MCP documentation](https://code.claude.com/docs/en/mcp).

## Codex CLI (remote MCP, per-job Checkout)

```bash
codex mcp add missing-manual --url https://missingmanual.ai/mcp
```

This direct remote setup intentionally uses a new Checkout for each job. Do not use it alongside the enrolled package: `npx -y missingmanual setup --client codex --email you@example.com` installs the local adapter globally at `~/.codex/config.toml` and replaces this legacy entry.

## Cursor (remote MCP)

Merge this entry into `mcpServers` in `~/.cursor/mcp.json` for all projects, or `.cursor/mcp.json` for this project. Preserve your existing servers.

```json
{
  "mcpServers": {
    "missing-manual": {
      "url": "https://missingmanual.ai/mcp"
    }
  }
}
```

See the [Cursor MCP guide](https://cursor.com/guides/coding-agent-mcp). Reconnect or restart your client if needed, then confirm it offers `find_papers`, `create_guide`, and `get_result`. `get_guide` remains compatible.

## Choose an action

- `find_papers` — Discover a candidate paper list in markdown, with abstracts and source links only. `maxPapers` is an integer from 1–30, default 10.
- `create_guide` — Request a research guide in markdown.

Both use the same checkout and receipt flow. Poll `get_result` for either action; `get_guide` remains compatible. Paper discovery on this path does not ingest full papers into a local repository or perform local QA.

## Request papers or a guide

Generate the idempotency key with a cryptographic random generator (for example, `crypto.randomUUID()`), not a topic, timestamp, or guessable sequence. Keep it stable for this request.

Call your chosen action without payment metadata. Use a focused `topic`, a cryptographically random, stable `idempotencyKey`, and `maxTotalChargeUsdMicros: 25000000` ($25, including the fee). Follow the connected tool schema for optional context and source constraints.

```json
{
  "topic": "Research the technical question and constraints agreed with the customer",
  "idempotencyKey": "REPLACE_WITH_A_CRYPTOGRAPHICALLY_RANDOM_KEY",
  "maxTotalChargeUsdMicros": 25000000
}
```

For `find_papers`, use the same common fields shown above and optionally add `"maxPapers": 10`. Keep the same action and identical input on retries.

The response contains `jobId`, `capability`, `status: "payment_required"`, a Stripe-hosted `paymentUrl`, `maximumAuthorizationUsdMicros: 25000000`, and `pollAfterSeconds`. Keep the entire initial response privately, including the payment URL and capability; share the checkout link only with the customer. Do not substitute example values. `maximumAuthorizationUsdMicros` is the requested maximum, not evidence of a hold. `authorizedUsdMicros` describes only an actually authorized amount.

## Approve the hold

Show the customer the returned `paymentUrl` and explain the **$25 card authorization hold**. The customer opens Stripe checkout and approves it. The agent must never enter payment details, collect card information, or approve payment on the customer's behalf.

Use the returned checkout expiry when provided; otherwise the payment link lasts **24 hours**. Research starts automatically once the server verifies authorization. Returning from Stripe is not proof of authorization; `get_result` is the source of status. Leaving checkout does not cancel the backend job. No research starts before verified authorization.

## Return to the agent

Poll `get_result` with the same `jobId` and `capability`, respecting `pollAfterSeconds`. Polling has no per-call fee. It can verify human payment and automatically start or resume the previously requested, approved research job; it never creates an additional paid job. Do not create another job because checkout is pending or research is still running. If an identical `find_papers` or `create_guide` retry is necessary, include the original `idempotencyKey` and the returned `capability` in the tool arguments. The optional `capability` field is required to replay an existing job; a replay without it returns a conflict. Do not include it on the initial request. If the initial response was lost and no payment URL was delivered, a new cryptographically random key may be used to retry; do not use this exception after receiving a checkout link.

Research can take **up to 90 minutes**. After successful settlement, `get_result` returns markdown and an itemized receipt. Save both. A completed guide ends with a **Verification** section: corrections against current primary documentation with their source URLs, claims that could not be verified, and the limits of the check. Report those limits rather than presenting the guide as unconditionally verified, and treat a correction as more current than the body text above it. Capabilities expire after **30 days**; keep them private and retrieve your result before expiry. There is no account-based recovery.

If checkout expires or status reports an error, explain the returned status and stop automatic retries; do not create a new paid request without the customer's direction. A failed or cancelled run charges $0 and fully releases or refunds the hold. `pricing_gap` also charges $0 and fully releases or refunds; a result stays withheld unless an operator records an auditable decision to release it free of charge. See [Pricing](/pricing.md).

## Optional advanced payment path

Clients with existing Stripe Shared Payment Token (SPT) support can still supply payment credentials in MCP protocol metadata under their caller's spending authority. SPT is optional; ordinary clients use hosted checkout. Never put credentials in tool arguments, prompts, files, logs, or output.

## Optional agent skill

The [MissingManual client skill](/skills/missingmanual/SKILL.md) describes safe creation, human payment approval, capability handling, polling, and receipts. The connected MCP tool schema remains authoritative.

## Check availability

```bash
curl -s https://missingmanual.ai/healthz
```

This reports service health and whether paid starts are enabled. It starts nothing and costs nothing.