Comma

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.

Add Comma to Cursor

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:

{
  "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 →.

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 →

Related