Claude Routines: Scheduled Tasks That Run on a Cadence

Claude routines are saved Claude Code configurations — a prompt, repositories, and connectors — that run automatically on Anthropic's cloud on a schedule, an API call, or a GitHub event. They put recurring agent work on autopilot, so a task fires on a cadence without you starting it each time.

Routine triggers, plan availability, and run caps verified 31 July 2026 against Anthropic's routines documentation.

If you have ever wanted Claude to send you a morning briefing, run a weekly research digest, or check something every night while you sleep, that is exactly the gap routines fill. Instead of opening a session and re-typing the same prompt, you save the work once and let it run. This guide explains what claude routines really are, which surfaces support scheduling today, the use cases that fit, and the guardrails that matter when an agent acts without you watching. Our take here comes from actually working with it, so the strengths and limits below are ones we have run into.

What Claude Routines Actually Are

A routine bundles a prompt, one or more repositories, a set of connectors, and a trigger, then runs the whole job autonomously as a full cloud session. Triggers can be a schedule, an HTTP POST, or a GitHub event.

A routine is a self-contained unit of automation. You give it a prompt that describes the job, pick one or more GitHub repositories for it to work in, choose which connectors it can reach, and attach a trigger that decides when it runs. From then on, Claude executes the whole thing autonomously as a full cloud session — it can browse files, run shell commands, read test output, and open pull requests, using the same abilities it has in an interactive session.

The important detail is where it runs. According to Anthropic's official routines documentation, routines execute on Anthropic-managed cloud infrastructure, not your laptop. That is the whole point: your machine can be closed and the scheduled tasks still fire. Think of a routine like a cron job, except instead of running a fixed shell script, you are scheduling an agent that understands your codebase and can decide what to do based on what it finds.

Routines support three trigger types, and a single routine can combine them:

1. Scheduled — run on a recurring cadence such as hourly, nightly, weekly, or weekdays, or once at a specific future time.
2. API — trigger on demand by sending an HTTP POST to a per-routine endpoint with a bearer token, so an alerting tool or deploy pipeline can start a run.
3. GitHub — run automatically in response to repository events such as a pull request opening or a release publishing.

Anthropic notes that routines are in research preview, so limits and the exact interface may shift. That is a fair reason to check the official docs before you build anything you depend on.

Which Surfaces Actually Let You Schedule Today

Cloud routines inside Claude Code are the native option on Pro, Max, Team, and Enterprise. Desktop scheduled tasks cover jobs needing local files, /loop repeats work inside an open session, and your own cron covers everything else.

This is where honesty matters, because "run Claude on a schedule" can mean several different things. Some are native, some are do-it-yourself. Here is the accurate picture of what schedules Claude work and how much plumbing you own.

The native option most people mean by claude routines is the cloud feature inside Claude Code. It is available on Pro ($20/month), Max ($100–$200/month), Team, and Enterprise plans with Claude Code on the web enabled, and you create one at claude.ai/code/routines or by typing /schedule in the CLI. You can compare those tiers on the Claude pricing page. If you are new to the underlying tool, our explainer on what Claude Code is is a good starting point before you wire up scheduled tasks.

There is also a genuinely local path. Desktop scheduled tasks run on your own machine rather than the cloud, which matters when a job needs access to local files. In the Desktop app you choose Remote for a cloud routine or Local for a desktop scheduled task — same idea, different execution environment.

Cowork is a different flavor of automation. It is about delegating background work rather than putting it on a clock, so it pairs well with routines rather than replacing them. If you are curious how that surface handles hand-offs, see what Claude Cowork is. And when no native scheduler fits — say you want Claude to summarize a data feed that lives outside a repo — the always-available route is the Anthropic API called from your own cron or scheduler, which our Claude API getting started guide covers end to end.

Good Use Cases for Claude Routines

The best fits are unattended and repeatable: overnight briefings that groom an issue queue, weekly digests of what changed, and alert triage where a monitoring tool posts to the endpoint and gets back a draft pull request.

Routines shine when the work is unattended, repeatable, and tied to a clear outcome. The official docs list several patterns, and they map neatly onto everyday needs.

Morning briefings are the classic one, and Anthropic's announcement of routines in Claude Code frames them exactly this way. A schedule trigger runs every weeknight, reads issues opened since the last run through a connector, applies labels, assigns owners, and posts a summary to Slack so your team starts the day with a groomed queue. Recurring research digests work the same way — scan what changed since yesterday and hand back a short readout.

Scheduled report generation is another strong fit. A weekly routine can scan merged pull requests, flag documentation that references changed APIs, and open update PRs for an editor to review. Monitoring and alert triage lean on the API trigger: your monitoring tool POSTs to the routine's endpoint when an error threshold is crossed, and the routine pulls the stack trace, correlates it with recent commits, and drafts a pull request with a proposed fix. On-call reviews a draft instead of starting from a blank terminal.

Because a routine can call any connector you attach, the reach is broad — Slack, Linear, your issue tracker, and more. Managing what a routine can touch is exactly what Claude connectors are for, so scope them deliberately. For heavier automations that split work into specialist steps, pairing routines with Claude Code subagents keeps each part of the job focused.

Honest Caveats Before You Automate

Runs happen with no approval prompts, so scope decides everything. Mind the daily run caps, keep pushes restricted to claude/ branches, and write a success report into the prompt, because a green status only means the session exited.

Scheduled agents are powerful precisely because nobody is watching — which is also the risk. A few caveats are worth internalizing before you turn anything on.

First, routines run without approval prompts. There is no permission picker during a run, so what a routine can reach is decided entirely by the repositories, environment, and connectors you attach. By default Claude can only push to claude/-prefixed branches, which is a sensible guardrail; do not lift that restriction unless you have a specific reason. Never point an unattended routine at destructive actions on a timer. Scope it to draft PRs and read-heavy work, and keep a human in the review loop.

Second, cost adds up. Routines draw down your subscription usage the same way interactive sessions do, and there is a daily cap on how many runs can start. On the current plans, Pro allows up to 5 routine runs per day, Max up to 15, and Team and Enterprise up to 25. If a job runs every hour, that adds up fast, so match the cadence to how often the answer actually changes.

Third, failures need alerting because nobody is watching. A green status only means the session started and exited without an infrastructure error — it does not mean your task succeeded. Blocked network requests, missing connector tools, and task-level mistakes all hide behind that green dot, so build a check into the prompt (for example, have the routine post "no changes needed" or a failure note to a channel you monitor). This is a different mindset from event-driven Claude Code hooks, which react to something you did; a routine acts on its own clock, so you have to design its own reporting.

This "green does not mean success" trap is one that has bitten us running our own scheduled jobs for InnovateTechie. Our nightly publisher exits cleanly whether or not it actually did the thing we intended, and for a while a silent no-op looked identical to a healthy run in the logs. What fixed it was writing the success condition into the task itself and routing that little report somewhere we would genuinely see it — the same discipline this advice describes, and worth building in from the first run rather than after a job has quietly done nothing for a week.

A quick freshness note on models: the routine creation form includes a model selector, and the newest option — currently Claude Opus 5 — is worth choosing for judgment-heavy jobs, while a lighter model keeps a high-frequency routine cheaper.

How to Start Simple

Prove one job first. Take something you already do by hand, write a self-contained prompt with an explicit success condition, choose a daily rather than hourly cadence, and read the first few transcripts before adding triggers.

Do not build a fleet of claude routines on day one. The reliable path is to prove one small routine, then expand.

• Pick one job you already do by hand, such as a nightly summary of yesterday's merged PRs.
• Write a self-contained prompt — because the routine runs alone, it must state exactly what to do and what success looks like.
• Set a modest cadence (daily, not hourly) and use Run now to test it immediately.
• Scope repositories and connectors to only what the job needs, and leave branch pushes restricted.
• Watch the first few runs, read the transcripts, and only then add triggers or frequency.

From the CLI you can create one conversationally — for instance /schedule daily PR review at 9am — and Claude walks you through the same details the web form collects. One-off runs like /schedule in 2 weeks, open a cleanup PR are handy reminders that fire once and then disable themselves.

Scheduling has four surfaces, not one — Claude schedule compares them on cadence, cost, and what silently breaks.