Comma

Use Comma with Mode

Mode does the BI work. Comma is where your team reviews the output. Connecting them gives you the strongest part of each tool without duplicating either.

The division of labor

Mode does the build. SQL workbench, R, Python notebooks, drag-and-drop dashboards, governed datasets, custom data apps, embedded analytics. The full BI arc from "raw data in the warehouse" to "rendered, governed report."

Comma does the review. Takes the rendered HTML, displays it faithfully inside an opaque-origin sandbox, and adds anchored Google-Docs-style comments on text and table cells. Routines re-run the underlying skill on a cron and post the new HTML as a revision. The same comma_sk_… token gates the REST API and the MCP server, so a Claude or Cursor agent is a first-class contributor.

Each tool keeps the slice it's best at. Neither tool pretends to be the other.

When the pair makes sense

  • You have an established Mode setup but the share-step ends in Slack screenshots, an email digest, or a Mode dashboard link reviewers won't open.
  • Stakeholders aren't Mode users. PMs, designers, execs, and customers open documents more readily than BI workspaces.
  • Reviewers outnumber editors. Mode's per-seat cost is steep for casual commenters; Comma doesn't paywall commenters per seat.
  • You want reports refreshed at a cadence outside Mode's tier. Comma routines run on every plan — monthly on Free, daily on Pro, hourly on Team.
  • You have an agent in the loop. A Cursor or Claude Code agent runs alongside your Mode workflow and needs somewhere scoped to post.

Three integration patterns

Pattern 1: Manual export → Comma report

The lightest setup. Run the Mode report, use Mode's "export HTML" or "download" function, and upload to a Comma report. Reviewers leave anchored comments. Next refresh, upload the new HTML and Comma appends it as a new revision on the same report — comments persist.

When to use it: One-off reports, monthly recurring reports where you don't need full automation, the first proof-of-concept.

Pattern 2: Comma routine re-runs the skill

The strongest setup. Wrap your Mode logic (or the data-fetching logic underneath it) as a Claude skill. A Comma routine fires on its cadence, executes the skill, and posts the resulting HTML as a revision on the target report. If you want Mode to remain the build engine, the skill can call Mode's API to pull the latest rendered output rather than re-implementing the SQL.

When to use it: Recurring reports with a predictable shape (daily ops digest, weekly analytics, monthly compliance). When you want the schedule, the cost cap, and the credential under one tool — Comma.

See routines documentation →.

Pattern 3: Mode scheduled report → Comma API

The tightest coupling. Mode fires its scheduled report. A small webhook or the Mode notification's destination calls Comma's /api/v1/reports/{id}/revisions endpoint, posting the rendered HTML as the next revision.

# At the end of a Mode scheduled report
curl -X POST https://commareports.com/api/v1/reports/$REPORT_ID/revisions \
  -H "Authorization: Bearer $COMMA_TOKEN" \
  -H "Content-Type: text/html" \
  --data-binary @./mode-export.html

When to use it: You already trust Mode as your scheduler and don't want two of them. Mode fires the run; Comma is the publication target with the comment layer attached.

What changes for reviewers

Before (Mode alone) After (Mode + Comma)
Open a Mode dashboard to leave a comment Open a document link, no Mode account required
Comments live in Mode threads Comments anchored to text and table cells in the rendered HTML
Refresh requires opening Mode Same link refreshes in place via routines
Reviewers may need a Mode seat Casual commenters don't add seat cost
Conversation lives in Slack alongside the link Conversation lives on the artifact

What stays in Mode

  • The warehouse connections and credentials.
  • The SQL workbench, R, and Python notebooks.
  • Governed datasets and the semantic layer.
  • The dashboard builder and custom data apps.
  • The full audit and compliance posture of an enterprise BI tool.

Comma doesn't try to replace any of this. Mode stays the source of truth for the how of the analysis; Comma carries the what to the people who need to review it.

Setup, end to end

  1. Pick the report shape. A daily ops digest? A weekly analytics summary? A monthly board report? Decide the cadence first.
  2. Have a Comma account. Free is enough to test the loop end-to-end with a monthly cadence.
  3. Create the Comma report. Either upload your current Mode output, or start with a placeholder. Set access for reviewers.
  4. Choose an integration pattern. Manual to start, routine when the shape is stable, API for tight coupling with Mode's scheduler.
  5. For Pattern 2: wire the routine. From the Comma report, Add routine →. Pick a skill that wraps your Mode logic (or that calls Mode's API). Set cadence and cost cap.
  6. Invite reviewers. They get a link, anchor comments where they want them, and the link refreshes in place at each cadence boundary.

Pricing for the pair

You keep paying Mode for what you use Mode for — enterprise BI seats. You add Comma at $15/month (Pro) or $75/seat (Team) for the share layer. For most teams, this is materially cheaper than adding more Mode seats just so reviewers can comment, because Comma's commenters don't count against editor seats.

See full Comma pricing →

Try the integration

The fastest way to feel the pair is on the Comma Free plan with a monthly cadence: export your latest Mode report, create a Comma report from it, invite two reviewers, and see how the surface changes. Move to Pattern 2 or 3 when the loop is worth automating.

Create your first report →

Related