Routines

Wire a skill to a schedule. Comma re-runs it and posts the new HTML as a revision on the same report.

Routines are Comma's hosted-cron primitive. You define what to run, how often to run it, and who to ping when the new revision lands. Comma handles the schedule, the execution, the cost cap, and the posting. The artifact you and your team already comment on stays in the same place — only the content underneath refreshes.

What a routine is

A routine has four parts:

A skill. The underlying instruction-set Comma will re-run. Typically a Claude skill — your repo's analysis script, an eval harness, a weekly digest generator. It runs against fresh data on every cadence.
A cadence. Monthly on Free, daily on Pro, hourly on Team, sub-hourly on Enterprise. The schedule lives in Comma; you don't run a cron daemon anywhere.
A target report. The new HTML lands as the next revision on the report you specify. Comments, share link, and access rules carry forward.
A cost ceiling. Every routine respects your plan's monthly Bedrock cap. Refuses rather than overflows.

That's the whole shape. No YAML pipeline, no DAG, no "workflow." Routines are scheduled runs.

Why hosted, and not your own cron

Most teams shipping recurring AI reports start the same way: a Python script on someone's laptop, a crontab line, a Slack webhook. It works for two weeks. Then the laptop sleeps, or the script fails silently, or the AWS bill arrives and nobody can tell which call was the expensive one, or the agent gets a token leak and there's no scoped credential to revoke.

Routines exist because that path is the wrong place to put your weekly Monday report. What Comma hosts for you:

The schedule itself. No cron daemon to maintain, no GitHub Action burning minutes, no Lambda you forgot you provisioned.
The execution. The skill runs on Comma's infrastructure against AWS Bedrock — directly, or through your own keys.
The cost ceiling. Per-plan monthly caps refuse runs that would overflow. Free is $0.50, Pro is $50, Team is $300. Pro includes $5/mo of Bedrock credit; Team includes $30.
The credential. A scoped comma_sk_… token. Revoke once and the schedule, the agent, and the API surface all stop together.
The posting. The new HTML lands as a revision on the target report, with the comment thread and access rules intact.

Bring your own Bedrock keys (Team)

Team users can bring their own AWS Bedrock keys. Runs bill to your AWS account; Comma applies a per-run safety cap instead of the monthly cap. Two reasons teams switch to BYOK:

Finance binding. The AI spend lives inside the AWS account that already has your committed-use discounts, your tagging policy, and your cost-allocation rules.
No markup. The metered Comma rail adds a small markup on top of Bedrock; BYOK skips it.

Switch in Settings → Bedrock keys. Either rail respects the per-run cap so a runaway prompt can't drain the account.

Cadence by plan

Plan	Cadence floor	Bedrock monthly cap	Included credit
Free	Monthly	$0.50	—
Pro	Daily	$50	$5
Team	Hourly	$300	$30 (or BYOK)
Enterprise	Sub-hourly	Custom	Custom (or BYOK)

Sub-hourly cadences require Enterprise because the failure modes change — retries, jitter, dedupe — and warrant a different SLA shape.

What you can run as a routine

A routine re-runs whatever the underlying skill does. That means it doesn't matter where the HTML comes from, as long as a skill can produce it. Common shapes:

A Claude skill. A self-contained Markdown skill (Anthropic's primitive) describing how to generate the report. Comma re-runs it against fresh data.
A model + a prompt. A bare prompt that produces structured HTML output. Useful for fixed templates.
A custom Python or Node script that hits your warehouse, your eval harness, or your dashboard tool, formats the result as HTML, and returns it.
A multi-step agentic skill — the kind a Claude or Cursor agent would follow if you asked it to "regenerate the Monday report."

Routines are agnostic about the inside of the run. They care about the schedule, the cost ceiling, the credential, and the posting.

Skills are the unit, not pipelines

Comma deliberately doesn't ship a visual pipeline editor. Routines are skills on a cron — the same instruction-set you'd hand to a Claude agent, with a schedule wrapped around it. If your skill is well-written, your routine is well-written. If your skill is brittle, your routine is brittle. The abstraction is a measuring instrument, not a workflow tool.

This is the same reason the comment layer doesn't try to be a project manager: the shape of a tool is also the shape of what it refuses to be.

Agents as first-class collaborators

Routines compose with the rest of Comma. The same comma_sk_… token that authorizes a routine also gates the REST API and the MCP server. So:

A Claude Code agent can create a routine through the REST API or the /comma-routine slash command in the official plugin.
A routine can post its output as a revision and ping reviewers.
A human reviewer can leave anchored comments on the new revision.
The agent can read those comments via the MCP server's list_comments tool and reply through reply_to_comment — same scoped token.

Scoped, revocable, rate-limited per token. The agent isn't a separate identity to manage — it's a credential you can pull at any time.

Common shapes

Daily Claude eval refresh. Re-run your eval harness against the latest model. Post the HTML as the next revision on the eval-results report. Stakeholders see the diff against yesterday.
Weekly analytics digest. Query the warehouse, format as HTML, post to the team report. Replaces "ops Slack message + screenshot at 9am Monday."
Monthly compliance digest. Run the compliance checks, format the output, post to a board-visible report. Audit trail lives in revision history.
Hourly dashboard refresh. A Team-plan routine that re-pulls the dashboard hourly and posts the new revision so on-call sees current state.

Each of these has a dedicated page that walks through the setup — see use cases below.

How to set one up

Have a report. Either create one from your skill's current output, or start with a placeholder.
Go to Routines. From the report page, Add routine →.
Pick a skill. Upload a Claude skill markdown file, paste a prompt, or reference a skill you've already registered.
Set the cadence. Monthly, daily, hourly — whichever your plan supports.
Set the cost ceiling. Defaults to your plan's monthly cap; tighten if you want.
(Optional) BYO Bedrock keys if you're on Team.
Save. The first run lands at the next cadence boundary. Subsequent runs post as new revisions on the same report.

What routines deliberately don't do

No visual pipeline. Skills are the unit. Compose them in your skill, not in a DAG editor.
No long-running workflows. A run that takes hours probably wants a different tool. Routines are best at "run a focused skill, post the result."
No data warehousing. Comma doesn't store your raw data. The skill fetches what it needs at run time.
No general-purpose cron. Routines post HTML to a Comma report. They are not a hosted cron for arbitrary side-effects.

Use cases

Pricing

Routines are bundled into every plan. There is no separate add-on.

Free — monthly cadence, $0.50 Bedrock cap.
Pro $15 / month — daily cadence, $50 Bedrock cap, $5 included credit.
Team $75 / seat / month — hourly cadence, $300 Bedrock cap, $30 included credit, BYO Bedrock keys.
Enterprise — sub-hourly cadence, custom caps, BYOK, SSO, audit log, DPA.

See full pricing →

Try a routine

The fastest way to feel the shape is to wire a Claude skill you already use to a monthly cadence on the Free plan. Even at monthly, the loop closes: report exists, skill runs, revision appears, comments persist.

Create your first routine →