Claude Code routines API trigger vs the Sume Scheduled run API

Both products let an external system start a saved agent with one HTTP POST, but they return different things. Claude Code routines return a session URL you open in a browser; Sume's Scheduled API returns a run receipt you can poll, cancel, cap by spend and receive as a signed webhook.

This post compares the two on the facts each vendor publishes. The Claude side comes from Anthropic's routines page, read on 2026-10-02, which marks routines as a research preview whose limits and API surface may change. The Sume side comes from Advanced: run a schedule via API and Runs and results.

What does each trigger call look like?

A routine's API trigger is a per-routine /fire URL with a per-routine bearer token, sent with an anthropic-beta header. The body takes one optional freeform text field, and the response carries a session id and session URL.

Sume's trigger is POST /v1/actions/{action_id}/runs with your API key, which needs the actions:read and actions:write scopes. The body takes input (an object), output_schema, generation_spend_cap_usd, on_active_run and communication.webhook_url. A 202 returns a receipt with status_url, result_url and cancel_url.

A practical difference shows up in what you store. A routine's token is scoped to one routine and is shown once, so you keep it in your alerting tool's secret store and rotate it by regenerating. A Sume key is a workspace key with scopes, so one key can start many schedules, and you narrow what it can do through scopes and per-run spend caps rather than one credential per schedule.

Neither page promises a stable contract forever. Anthropic ships /fire under a dated beta header and says request shapes, rate limits and token semantics may change in the research preview. Sume's exact request and response schemas come from the live OpenAPI document at https://api.sume.com/reference/json, and the docs tables are described as a readable summary, not a second schema.

How is caller data kept from acting as instructions?

Both treat caller data as data. Anthropic says the text value arrives wrapped in a block that labels it untrusted and tells Claude not to follow instructions inside it unless the routine's own prompt says to, so the saved prompt has to reference the payload explicitly.

Sume does the same in spirit: input is serialized into a fenced JSON block and handed to the agent as data, and the behavior still comes from the schedule's saved instructions. The practical rule for both is to write the saved instructions so they name the data they expect, and never design a trigger that lets the payload redirect the task.

There is a cost to this design on both sides. Because the payload cannot instruct the agent, a trigger that is supposed to change the task, for example a different goal per call, needs a different saved routine or schedule, or a different surface. In Sume's case that is the point of Agent Completions: the instruction itself is supplied per request, with a required spend cap, and nothing is saved.

What limits and guardrails apply?

Anthropic lists hourly limits per way of starting a run, for example 30 per hour per routine shared by Run now and API fires, and 100 API fires per hour per account. Those are counts, not money; routines draw down subscription usage.

Sume's guardrails are about spend. A schedule has a generation spend cap that defaults to $1.00 per run when unset. A caller can lower it for one run with generation_spend_cap_usd but never raise it, and sending null removes the automation ceiling while wallet balance and org limits still apply. Both are real controls, aimed at different risks: runaway call volume versus runaway generation spend.

How do you know the run finished?

Anthropic's page warns that a green status in the run list only means the session started and exited without an infrastructure error, so you open the transcript to see whether the task succeeded. Sume gives you a status you can branch on (queued, processing, completed, failed, canceled, skipped) and one signed POST when a run completes or fails, if you set a webhook URL.

Two honest limits on the Sume side: a canceled or skipped run never delivers a webhook, so read the status instead; and the Developer API cannot create or edit a schedule, which you do in the dashboard. There is no MCP tool or CLI command for Scheduled runs either.

One more difference is who the run acts as. Anthropic notes that routines belong to an individual account and that commits, pull requests and connector actions appear as that user. Sume runs a schedule as an agent in a fresh thread in your workspace, and the public API reaches only your own schedules for now: team-workspace Actions are not reachable over the public API yet, by either the opaque or the vanity path.

curl -sS -X POST "https://api.sume.com/v1/actions/$ACTION_ID/runs" \
  -H "Authorization: Bearer $SUME_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"input":{"alert":"checkout latency above threshold"},"generation_spend_cap_usd":0.5}'

Which should you pick?

If the work is a coding task against a GitHub repository, a routine is built for it. If the work is media generation that must return a typed result, stay inside a spend cap and notify your backend, the Scheduled API is the closer fit. They are not exclusive: a routine can call out to your own service, which can in turn fire a Sume run. For the wider choice between Sume's three run surfaces, see Agent Completions vs Format vs Scheduled.