# Where Do Claude Code Routines Post Their Reports?

Canonical: https://commareports.com/agents/where-do-claude-code-routines-post

> Claude Code Routines schedule the agent's work but don't say where a report should land. Session logs, Slack, and PRs each lose the review loop. Comma is the destination: publish via MCP, review with anchored comments, revise on the next run.

# Where do Claude Code routines post their reports?

Anthropic shipped Routines for Claude Code in April 2026: schedule a
recurring task, and the agent runs it without you opening a session. A
nightly eval sweep, a Monday-morning metrics digest, a weekly dependency
audit — the scheduling problem is solved.

The destination problem isn't. A routine defines _when_ the agent runs and
_what_ it does. It does not define where a **report** should land. Out of
the box you get three options, and each one drops part of the loop.

## The three defaults, and what each loses

**Session logs.** The work happened; the transcript proves it. But a
transcript is not a document. Nobody on your team opens last Tuesday's
session log to check whether the conversion funnel moved, and there is no
way to comment on it.

**A Slack notification.** Fine as a doorbell — "the report is ready" —
but wrong as the artifact. The HTML becomes a snippet or an attachment,
feedback scatters across thread replies, and next week's run buries this
week's. We've written up the failure modes in
[Where should my agent post its work?](/agents/where-should-my-agent-post)
— Slack is option one of four, and it falls apart the same way for
scheduled runs, just faster, because the runs keep coming.

**A pull request.** Exactly right when the routine's output is code. Wrong
when it's a report: a rendered analytics digest reviewed as an HTML diff
is unreadable, PR comments anchor to source lines rather than rendered
content, and merging a report into `main` every night is version-control
noise, not review.

What's missing from all three is the second half of the loop: the team
reads the report _as a document_, leaves feedback _on the content_, and
the agent _reads that feedback_ before its next run.

## The shape that closes the loop

1. **The routine runs** on its schedule and produces HTML.
2. **The agent publishes** it to Comma over MCP — `create_report` on the
   first run, `update_report` on every run after, so the share link your
   team bookmarked refreshes in place instead of multiplying.
3. **The team reviews** it like a Google Doc: comments anchored to the
   exact paragraph or table cell, threads, resolution. Reviewers don't
   need a seat — commenting is free on every plan.
4. **The next run reads the feedback.** The agent calls `list_comments`,
   sees each comment with the text it's anchored to ("this regression
   table is missing the p95 column"), addresses it, replies with
   `reply_to_comment`, and resolves the thread with `set_comment_status`.

Schedule → publish → review → revise, with the routine driving the
schedule and Comma carrying everything after.

## Wiring it up

One line installs the Comma plugin for Claude Code:

```bash
curl -fsSL https://commareports.com/install.sh | sh
```

The installer attaches Comma's hosted MCP server, registers the
`/comma-publish`, `/comma-search`, `/comma-routine`, and `/comma-link`
slash commands, and walks you through creating a `comma_sk_…` token. The
token is scoped and revocable from **Settings → API tokens**; it gates the
MCP server, the REST API, and anything the routine publishes — one revoke
pulls the agent's access everywhere.

Then make the destination part of the routine's task. The instruction is
ordinary prose in the routine definition:

```
Run the weekly retention analysis. Before finishing:
1. Call list_comments on report <id> and address any open threads.
2. Publish the updated HTML to the same report with update_report.
3. Reply to each comment you addressed and mark it resolved.
```

On the first run, swap step 2 for `create_report` and post the returned
share link to your team channel — Slack goes back to being the doorbell,
and the document lives at a stable URL.

## One distinction worth knowing

Comma also has its own scheduling primitive, called
[routines](/features/routines) — a hosted cron that re-runs a skill and
republishes a report at any cadence, free and unlimited on every plan; you
pay only for the AI compute each run uses (bring your own Bedrock key, or
draw down prepaid credit). The two compose either way:

- **Claude Code Routines drive, Comma is the destination.** The schedule
  and the execution live in your Claude Code environment; Comma receives
  the output over MCP. Pick this when the task needs your local code,
  credentials, or tooling.
- **Comma routines drive end to end.** The schedule, the run, the cost
  cap, and the publishing all live in Comma. Pick this when the report is
  the whole job and you'd rather not keep a machine awake for it.

Either way, the review surface — anchored comments, share roles, revision
history on a stable link — is the same.

## Try the loop

The Free plan covers the whole loop on demand: publish over MCP, share the
link, collect anchored comments, let the agent respond. Comma's own routines
are free and unlimited at any cadence too — you pay only for the AI compute
each run uses.

**[Install the plugin](https://commareports.com/install.sh)** or
**[create your first report →](https://commareports.com/)**

### Related

- [Where should my agent post its work?](/agents/where-should-my-agent-post)
- [Use Comma with Claude Code](/mcp/claude-code)
- [Let an agent respond to comments](/agents/let-an-agent-respond-to-comments)
- [Hosted cron for AI agents](/features/routines/cron-for-ai-agents)