> ## Documentation Index
> Fetch the complete documentation index at: https://docs.pome.sh/llms.txt
> Use this file to discover all available pages before exploring further.
# Quickstart w/ Cursor
> Add the Pome MCP server to Cursor, paste one prompt, and get your first scored agent report in about 10 minutes.
**About 10–12 minutes** end to end: install the skills,
add the MCP server, paste one prompt. You should get a **failing score
(\~33/100) on purpose**, then flip one line and go green.
Pome gives your agent a graded exam. Three roles make it work:
* **Examinee** — a clone of the agent under test. It works a real task against
**digital twins** of GitHub and Slack (deterministic fakes with the same API
shapes as production), and every tool call is recorded.
* **Coach** — your Cursor session. It installs, connects, launches the run, and
brings the results back into the conversation.
* **Judge** — Pome's scorer. It reads the recorded trace and grades it against
the task's acceptance criteria, 0–100.
If you already have your own agent in a repo, run this example first to learn
the loop, then see [Connect Your Agent To Pome](/existing-agent) to register it
and get a `pome.config.json`.
## What you're about to run
The quickstart uses a bundled **support-triage** example — a small local agent
(Claude Agent SDK), not your repo.
* **Role.** Support-triage bot for the Acme eng org: watch `#support` on Slack
for bug reports, track each as a GitHub issue in `acme/orders-service`, and
post the issue link back to the thread.
* **World.** Deterministic **GitHub + Slack twins**: same API shapes as
production, no real users or data.
* **The exam.** A customer re-reports a bug that **open issue #1 already
tracks**. A good agent searches first, comments on #1, and links that issue
back. The bundled v1 agent is chartered *not* to search, so it files a
**duplicate** issue. It still does real work (concrete repro steps), so the
first score is **\~33, not 0**.
* **Why this example.** The fail → fix → pass story is one line of system
prompt (`TRIAGE_RULE`), which you flip at the end of this page.
## What the paste-prompt does
When you paste the prompt below, Cursor becomes the coach. It will show a short
checklist and ask **"Shall I proceed?"** before running anything. At a high
level it will:
1. Fetch and build the local support-triage examinee
2. Sign you into Pome (OAuth) and confirm identity / quota
3. Register the example as an agent on your team
4. Save the duplicate-issue exam into your catalog
5. Start a live twin session for that exam
6. Spawn the local examinee against those twins
7. Finalize the run while the twin session is still live (the one hard rule)
8. Show the score, criteria table, and dashboard link in the chat
You stay in control: every command is plain text, shown before it runs.
## Before you start
* **Cursor** installed and signed in.
* The example examinee is a small
[Claude Agent SDK](https://docs.claude.com/en/agent-sdk/typescript) process
that runs as its own subprocess, so it needs its own Anthropic credential —
an `ANTHROPIC_API_KEY` in your environment, or a `claude` login. Cursor's own
subscription does not cover it.
* **Node 18+** with `npm` and `npx`.
* No Pome account needed up front: adding the server in step 2 is config only,
and the OAuth consent screen opens on the first tool call in step 3 — that is
where you sign in or sign up, no credit card.
## 1. Install the coach skills
```bash theme={"dark"}
npx skills add pome-sh/digital-twins
```
The [`skills` CLI](https://github.com/vercel-labs/skills) installs the Pome
coach skill set from
[`pome-sh/digital-twins`](https://github.com/pome-sh/digital-twins/tree/main/skills)
into your agent's skills directory — choose **Cursor** when the installer asks.
Five skills, one job each: `pome` (entry router), `pome-intake` (scope the
agent), `pome-author-task` (write exams), `pome-verify-seed` (check seed state),
and `pome-run-task` (launch, finalize, report). Together they teach Cursor the
full loop.
## 2. Connect the Pome MCP
Add Pome as a remote MCP server. Create or edit `~/.cursor/mcp.json`:
```json theme={"dark"}
{
"mcpServers": {
"pome": {
"url": "https://mcp.pome.sh/mcp"
}
}
}
```
Prefer clicking? **Cursor Settings → MCP → Add** and enter the same name
(`pome`) and URL (`https://mcp.pome.sh/mcp`).
Every command here is plain text you can read before you run it — the install
path never pipes a script into your shell and never injects remote config.
There is no API key to paste: on the first tool call, your agent discovers the
OAuth metadata and opens the Clerk consent screen (scopes: verify your
identity, basic profile, email address). Sign in — or sign up right there — and
the tools appear.
## 3. Paste the prompt
Open Cursor anywhere (the example brings its own agent — your repo is not
required) and paste:
```text theme={"dark"}
Test my agent with pome, using the bundled support-triage example, and take it
all the way to a finalized, scored run.
First, present me this plan as a short checklist and ask "Shall I proceed?"
before running anything. Wait for my yes.
1. Fetch the example pack and build the local examinee:
npx degit pome-sh/digital-twins/examples/support-triage support-triage
cd support-triage/local && npm install
2. On the pome MCP, call get_started, then get_platform_context with
door: "cursor" to confirm identity and quota (the door tag is for
onboarding analytics — pass it verbatim).
3. Register the examinee: register_agent with name "support-triage" and
twins ["github", "slack"]. Keep the agent id.
4. Save the exam into my team catalog: save_task with the full contents of
../tasks/duplicate-issue.md as task_source and the name
"support-triage-dedup". Keep the task id.
5. run_task(task_id, agent_id). Keep session_id, agent_token, examinee_task,
and examinee_launch from the response.
6. Spawn the examinee as a local subprocess. First confirm it can authenticate:
the examinee is a Claude Agent SDK process needing its own Anthropic
credential, so if neither ANTHROPIC_API_KEY nor a `claude` login is present,
stop and tell me instead of launching a process that cannot start. Then from
support-triage/local, run `npm run start` with env injected from the
run_task response —
POME_GITHUB_MCP_URL and POME_SLACK_MCP_URL from the github and slack
entries' url in examinee_launch.mcp_servers (not examinee_launch.env,
whose URLs are REST), POME_AUTH_TOKEN = agent_token,
POME_TASK = examinee_task.prompt. POME_AUTH_TOKEN is env-only: never
write it to a file.
7. The instant the process exits, call finalize_run(session_id, agent_token)
— before any cleanup, while the twin session is still live.
8. get_report(run_id). Give me the score, the criteria table, and a plain
summary of what failed and why, here in the conversation, plus the
dashboard link.
Guardrails: pause after the checklist for my go-ahead; keep every command plain
text and show it to me before running; never pipe remote scripts into a shell;
secrets stay in env vars; don't ask me for a Pome API key — the OAuth consent
screen handles Pome auth. That does not cover the examinee's own Anthropic
credential, which is the one thing you should flag if it is missing (step 6).
```
Cursor does the rest: it seeds live GitHub + Slack twins, launches the examinee
against them, waits for it to finish, finalizes, and narrates the report.
The twin tape lives in the running session. `finalize_run` must be called while
the session is still live — the installed `pome-run-task` skill enforces this,
and the prompt repeats it because a session that expires first cannot be scored.
## What the score means
Expect **33, not 0 — and not 100**. That matches the exam above: the examinee
did real work (concrete repro steps earn the 33) but filed a duplicate, so both
duplicate-detection criteria fail. The report names which criterion failed and
what the judge saw — the failure a happy-path demo never surfaces.
## The one-line fix
The whole story is one line of the examinee's system prompt: `TRIAGE_RULE` in
`support-triage/local/src/index.ts`. Swap it for the commented `TRIAGE_RULE_V2`
right next to it (*search open issues first; comment on the existing issue
instead of opening a second one*), then tell Cursor:
```text theme={"dark"}
Apply the TRIAGE_RULE_V2 fix in support-triage/local/src/index.ts and re-run
the same task (steps 5–8). Show me the score delta.
```
Same exam, same twins, green run. That loop — run, read the failure, fix,
re-run — is the product.
## Open your first report
`get_report` prints the score, the criteria table, and the dashboard link right
in your conversation. Open the link to see the finalized report — a **failing**
run where the "33, not 0" story is legible: which criterion failed, and exactly
what the judge saw.
Stuck before your own run lands? Look at a real one — no signup:
[the failing baseline](https://app.pome.sh/demo/grp_-WxylAM068osJlDWYRTihUUP) and
[the same task after the one-line fix](https://app.pome.sh/demo/grp_utwJ34M42NHX64jF170J5iaT).
## Next
The coach loop behind the paste-prompt, call by call.
Point Pome at your own repo and get a scored run.
`validate_task` → `save_task` → `verify_seed` — graded exams for *your* agent.
Where runs, traces, and judge feedback live: app.pome.sh.