Claude Code Gets "Routines" — Cloud-Based AI Automations That Run While You Sleep

Anthropic shipped routines for Claude Code on April 14, 2026. A routine is a saved configuration: a prompt, one or more GitHub repos, and a set of connectors, all running on Anthropic's cloud infrastructure without your laptop being open. They also rebuilt the entire desktop app around parallel sessions. Here's what actually matters.

A routine is basically a cron job that can think. You write a prompt, point it at your repos, wire up connectors (Slack, Linear, Google Drive), and attach a trigger. When the trigger fires, Claude spins up a full cloud session, clones your repos, and runs whatever the prompt describes.

The important difference from regular cron or GitHub Actions: a routine doesn't execute a static script. It runs a complete Claude Code session that can reason about what it finds and adapt when things look different than expected. It has access to any tools or skills in the cloned repo.

You get three trigger types, and you can stack them on a single routine:

Create routines from the web UI at claude.ai/code/routines, from the CLI with /schedule, or from the redesigned desktop app. All three sync to the same cloud account.

These aren't hypothetical. They're problems I've watched teams solve with duct tape and half-abandoned scripts:

Automated code review. A GitHub trigger on pull_request.opened runs your team's custom review checklist. It leaves inline comments on security and performance issues and writes a summary comment so human reviewers can skip the mechanical stuff and focus on design.

Deploy verification. Your CD pipeline hits the routine's API endpoint after each production push. The routine runs smoke checks, scans error logs for regressions, and posts a go/no-go verdict to your release channel. Replaces the "did anyone check if the deploy broke something?" ritual.

Alert triage. Your monitoring tool crosses an error threshold and calls the routine with the alert body. Claude correlates the stack trace with recent commits and opens a draft PR with a proposed fix. On-call reviews the PR instead of starting from a blank terminal at 3am.

Docs drift detection. A weekly schedule scans merged PRs, flags documentation that references changed APIs, and opens update PRs. The task everyone agrees should happen but nobody owns.

Here's what triggering a routine from a deploy pipeline looks like:

curl -X POST https://api.anthropic.com/v1/claude_code/routines/trig_01ABC.../fire   -H "Authorization: Bearer sk-ant-oat01-xxxxx"   -H "anthropic-beta: experimental-cc-routine-2026-04-01"   -H "anthropic-version: 2023-06-01"   -H "Content-Type: application/json"   -d '{"text": "Sentry alert SEN-4521 fired in prod."}'

You get back a session ID and URL so you can watch the run live or review what happened after.

This is a research preview, and the caps reflect that:

| Plan | Daily Runs | |------|-----------| | Pro | 5 | | Max | 15 | | Team/Enterprise | 25 |

Five runs a day on Pro is enough to test the feature, not enough to rely on it. If you want this in an actual workflow, you need Max or higher. Team and Enterprise plans can enable overage billing to go past the cap.

Other details that matter:

This isn't a replacement for cron or GitHub Actions. The way I think about it:

Cron handles anything that needs exact, repeatable, testable behavior. Backup scripts, log rotation, data pipelines.

GitHub Actions handles deterministic CI/CD. Builds, tests, linting, deployments. Anything where you want an audit trail and pipeline control.

Routines fill the space where you currently rely on a person to interpret context. Review summaries, risk analysis, documentation updates, backlog triage. Work that's too nuanced for a shell script but too tedious for a human to do daily.

A practical pattern: cron collects the data, routines interpret and act on it.

The other half of this release is a full rebuild of the Claude Code desktop app. The old single-session window is gone.

What's new:

Available on macOS and Windows now. Linux is coming in the next few weeks. The app matches CLI plugin functionality, so organizations can manage plugins centrally across both environments.

Routines are the most interesting Claude Code addition since agentic coding landed. Not because the use cases are new. Teams have been stitching together GitHub Actions, custom webhooks, and scripts to do all of this for years. The difference is that routines remove the glue code.

The Register called these "mildly clever cron jobs," and that's honestly not unfair. The daily run limits are tight. Multi-session workflows will burn through tokens. Both valid concerns.

But here's the thing: the pattern of scheduling an AI agent to handle interpretive work that humans keep putting off is practical. If you've wanted automated code review that understands your team's conventions, or deploy verification that can reason about what went wrong instead of checking boxes, this is the infrastructure for building that.

The desktop redesign is solid, not groundbreaking. Multi-session support and the integrated terminal were long overdue. The drag-and-drop layout is more flexible than I expected.

My recommendation: start with one routine. Pick the most annoying repetitive task on your team, the one everyone agrees should be automated but nobody has written the script for. That's your first routine.