# Use Comma with Cursor — publish HTML reports from your agent

Canonical: https://commareports.com/mcp/cursor

> Add the Comma MCP server to Cursor in one config edit. Your Cursor agent can publish HTML reports, search the workspace, and read and reply to anchored comments under a scoped token.

# Use Comma with Cursor

Cursor supports the Model Context Protocol natively. Add Comma as an MCP
server in your Cursor config and the agent picks up the full set of report
and comment tools — same scoped token shape as the REST API.

## One-click install

Cursor supports install deeplinks — clicking this from a machine with
Cursor installed opens the MCP install prompt with Comma pre-filled:

**[Add Comma to Cursor →](cursor://anysphere.cursor-deeplink/mcp/install?name=comma&config=eyJ1cmwiOiJodHRwczovL2NvbW1hcmVwb3J0cy5jb20vYXBpL21jcCIsImhlYWRlcnMiOnsiQXV0aG9yaXphdGlvbiI6IkJlYXJlciBZT1VSX0NPTU1BX1RPS0VOIn19)**

The deeplink ships with a placeholder credential. After installing, open
**Cursor Settings → MCP → comma** and replace `YOUR_COMMA_TOKEN` in the
`Authorization` header with a real token from
**Settings → API tokens → New token** on Comma — the server won't
authenticate until you do.

Prefer to see exactly what lands in your config? Use the manual path
below — it's the same entry.

## Add Comma to Cursor manually

Open your Cursor MCP configuration. Most setups use one of:

- **Global:** `~/.cursor/mcp.json`
- **Per workspace:** `.cursor/mcp.json` in the project root

Add a Comma entry:

```json
{
  "mcpServers": {
    "comma": {
      "url": "https://commareports.com/api/mcp",
      "headers": {
        "Authorization": "Bearer comma_sk_…"
      }
    }
  }
}
```

Replace `comma_sk_…` with a token from
**Settings → API tokens → New token** on Comma. Scope it to the actions you
want the agent to take (typically `reports:write` and `comments:write`).

Restart Cursor. The agent now sees the Comma tools.

## What the agent can do

Once Comma is attached, the agent has the full MCP toolset:

| Capability                | Tools                                                                    |
| ------------------------- | ------------------------------------------------------------------------ |
| Publish a report          | `create_report`, `update_report`                                         |
| Find existing reports     | `list_reports`, `search_reports`, `get_report`, `read_report`            |
| Leave / reply to comments | `add_comment`, `reply_to_comment`, `set_comment_status`, `list_comments` |
| Request review            | `request_review`                                                         |
| Manage assets             | `upload_report_asset`, `list_report_assets`, `delete_report_asset`       |

The agent picks the right tool from its reasoning — there are no
Cursor-specific commands to memorize.

## Common workflows

### Publish at the end of a task

You ask Cursor to "summarize this PR's changes and publish a release note
to Comma." The agent:

1. Reads the diff and your codebase context.
2. Generates HTML for the release note.
3. Calls `create_report` to publish.
4. Returns the share link.

### Pull context from prior reports

You ask Cursor to "look at last month's eval results and update the failing
prompts." The agent:

1. Calls `search_reports("eval results")` to find the latest one.
2. Calls `read_report` to load the HTML.
3. Reasons about which prompts are failing.
4. Edits the prompts in your repo.
5. Optionally calls `add_comment` on the eval report to record the change.

### Carry on a thread

You ask Cursor to "address the comments left on last week's analytics
report." The agent:

1. Calls `list_comments` on the report.
2. Reads the open threads, including the anchored text.
3. Makes the requested changes (in code, in data, in copy).
4. Calls `reply_to_comment` to summarize what changed.
5. Optionally calls `set_comment_status` to mark threads resolved.

## Token shape

The token in your Cursor config:

- Lives in `~/.cursor/mcp.json` (or workspace `.cursor/mcp.json`). Treat it
  like an API key: avoid committing the per-workspace file if your repo is
  public.
- Is scoped — you choose which actions it can take when you create it on
  Comma.
- Is revocable in one click from **Settings → API tokens**. Revocation
  applies immediately to the REST API, the MCP server, and any routines
  the token created.
- Is rate-limited per token.

For an extra layer, create separate tokens per project — one per workspace
`.cursor/mcp.json` — and revoke individually when a project ends.

## The deliberate scope

Comma's MCP surface is intentionally narrow:

- Reports, comments, asset management, review requests.
- No code execution on Comma's side; the agent runs on your machine.
- No data layer; the agent's skill fetches its own data.
- No cross-posting to Slack/email/GitHub; Comma posts to a Comma report.

If you want refresh-on-a-cron behavior alongside the on-demand MCP surface,
attach a routine — see [Routines →](/features/routines).

## Try it

Drop the snippet into `mcp.json`, generate a token, restart Cursor, and ask
the agent to publish anything you have lying around as HTML. From the web
UI, leave a comment and ask the agent what it sees on its next turn.

**[Generate a token →](https://commareports.com/settings/tokens)**

### Related

- [Comma MCP server overview](/mcp)
- [Use Comma with Claude Code](/mcp/claude-code)
- [Where should my AI agent post its work?](/agents/where-should-my-agent-post)
- [Routines — hosted cron for AI skills](/features/routines)