What's a Claude skill?

A Claude skill is a self-contained Markdown file that describes a focused job — how to write a weekly report, run an eval, summarize tickets, refresh a digest. It's Anthropic's primitive for packaging instructions an agent can follow consistently. Routines re-run your skill on a schedule.

Where does Comma run the skill?

On Comma's infrastructure, against AWS Bedrock. Either the metered Comma rail (with a small markup and a per-plan monthly cap) or — on Team — your own AWS Bedrock keys so usage bills to your AWS account.

What happens if the skill fails?

Failed runs are recorded on the routine's run history, with the error surfaced in the Comma UI. The report keeps its last successful revision. You don't lose the previous output.

Do I need to write a cron expression?

No. Pick a cadence — monthly, daily, hourly — and Comma handles the scheduling. Cron expressions are available for Team if you want finer control.

Run a Claude skill on a schedule

You wrote the skill. Comma runs it.

The job

You've written a Claude skill that produces something useful — a weekly analytics digest, a daily eval report, a Monday morning ticket summary, a monthly compliance check. It works when you run it by hand. The hard part is not the skill. The hard part is running it on a schedule, reliably, without babysitting a Mac mini or a Lambda.

That's the job routines do.

The shape

Have a Claude skill. A Markdown file describing the job — your repo's skill, a public one, or one you wrote inline.
Have a Comma report. Either start with the skill's current output, or begin with a placeholder.
Wire the routine. From the report, Add routine → Pick the skill, pick a cadence (monthly on Free, daily on Pro, hourly on Team), set a cost ceiling.
Done. Comma re-runs the skill against fresh data at each cadence boundary and posts the new HTML as a revision on the report.

No cron daemon. No Mac mini. No "I'll just re-run it Monday morning" appearing in your todo list forever.

Why hosted is the right primitive here

Running a Claude skill yourself looks easy at the start:

Spin up a Lambda or a GitHub Action.
Write the credential rotation.
Pipe the output somewhere your team can find it.
Slack the link.
Handle the next time the skill fails or the API key rotates.

Each step is small. The compounding cost is real. What you're paying for, in hours-per-month, is the operational surface around a recurring AI run, not the run itself.

Routines collapse that surface to a configuration form. The skill executes, the artifact posts, the cost stays capped, the credential stays scoped — all under one comma_sk_… token you can revoke at any time.

Cost shape

Every run hits AWS Bedrock. Comma caps the bill two ways:

Per-plan monthly cap. Free $0.50, Pro $50, Team $300. Refuses rather than overflows.
Per-run safety cap. A ceiling on what a single run can cost. Useful when a runaway prompt would otherwise burn through the monthly budget in one execution.

Pro includes $5/month of Bedrock credit; Team includes $30. Team can also bring its own AWS Bedrock keys — usage then bills directly to your AWS account, and the per-run cap is the only ceiling that applies.

Cadence by plan

Plan	Cadence floor	Monthly Bedrock cap	Notes
Free	Monthly	$0.50	One routine, monthly run, $0.50 ceiling
Pro $15/mo	Daily	$50	$5 included credit
Team $75/seat	Hourly	$300	$30 included credit; BYO Bedrock keys
Enterprise	Sub-hourly	Custom	Custom cap, BYOK, SSO, audit log, DPA

What you can put in the skill

Anything a Claude agent could do during a focused task: query your warehouse through a connector, hit your eval harness, summarize tickets from Linear, pull yesterday's metrics from PostHog, run a check against your dashboard tool's API, format the result as HTML, and return it.

The skill is the unit. Comma is agnostic about the inside of the run.

How agents fit

The same comma_sk_… token that authorizes a routine also gates the REST API and the MCP server. So an agent in Claude Code or Cursor can:

Create or update a routine — through the REST API or the official plugin's /comma-routine slash command.
Read the run history via the REST API.
Read anchored comments left on the new revision via the MCP server's list_comments tool and reply with reply_to_comment.

When the routine posts a new revision, reviewers can leave comments. The agent reads them on its next run and adjusts the next output. The loop closes.

Setup, end to end

POST /api/v1/routines
{
  "report_id": "rpt_…",
  "skill_id": "skl_…",     // or "skill_body": "<markdown>"
  "cadence": "daily",      // monthly | daily | hourly | "0 9 * * 1" (Team+)
  "cost_cap_per_run_usd": 1.50,
  "notify_on_revision": ["amir@example.com"]
}

The same scoped token gates the REST API, the MCP server, and any routine created under it. The MCP server today exposes report and comment tools; routine creation runs over REST or the plugin's /comma-routine slash command.

Try it

The fastest end-to-end is on the Free plan with a monthly cadence and a skill you already use. The shape is identical at higher cadences — the only difference is how often the loop fires.

Create your first routine →