# Run a Claude Skill on a Schedule | Comma Routines

Canonical: https://commareports.com/features/routines/run-claude-skill-on-schedule

> Wire any Claude skill to a daily, hourly, or monthly schedule. Comma re-runs it against fresh data and posts the new HTML as a revision on your report. No cron daemon to maintain.

# 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

1. **Have a Claude skill.** A Markdown file describing the job — your repo's
   skill, a public one, or one you wrote inline.
2. **Have a Comma report.** Either start with the skill's current output, or
   begin with a placeholder.
3. **Wire the routine.** From the report, **Add routine →** Pick the skill,
   pick a cadence (any cadence, any plan), set a per-run spend limit.
4. **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. You pick how that compute is billed:

- **Prepaid credit.** Use Comma's keys and draw down a prepaid balance (at
  cost plus 20%). Hosted runs pause at a $0 balance rather than overflowing
  into a surprise invoice.
- **Bring your own Bedrock key.** Bill runs straight to your AWS account —
  free on Comma, on any plan.

A per-run safety cap also applies on either rail: a ceiling on what a single
run can cost, useful when a runaway prompt would otherwise burn through your
balance in one execution.

## Cadence

Routines run at any cadence — monthly, daily, hourly, or sub-hourly — on
every plan. Pick the schedule that matches how often your data refreshes;
there's no cadence gate to work around.

| Cadence    | Typical use                                      |
| ---------- | ------------------------------------------------ |
| Monthly    | Board prep, retros, monthly compliance digests   |
| Daily      | Eval refresh, ops summary, daily digest          |
| Hourly     | On-call dashboards, refresh-on-tick reports      |
| Sub-hourly | Tight refresh loops with retries, jitter, dedupe |

## 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" (any plan)
  "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 a skill you already use, wired to a routine — any
cadence, free to set up. The shape is identical at every cadence; the only
difference is how often the loop fires.

**[Create your first routine →](https://commareports.com/)**