Claude Routines vs Scheduled Tasks vs /loop — which one should you use?

Claude now has three different ways to run tasks automatically. Three. And if you're anything like most people, you're wondering: what's the difference, and which one do I actually need?

The short answer: they run in different places, have different triggers, and solve different problems. The long answer is this article.

The three automation modes at a glance

Before we dive deep, here's the quick version:

Routines — run in Anthropic's cloud. Work while your laptop is closed.
Desktop Scheduled Tasks — run on your machine via the Claude Desktop app. Need your computer to be on.
/loop — run inside your current Claude Code session. Temporary and session-scoped.

Think of it this way using a Bubble analogy: Routines are like Bubble's Backend Workflows (they run on the server regardless of what you're doing). Desktop Tasks are like Recurring Workflows on a page (they need the page open). And /loop is like a Do Every X Seconds action inside a workflow — temporary, only while you're there.

Feature-by-feature comparison

Feature	Routines	Desktop Tasks	/loop
Where it runs	Anthropic cloud	Your machine	Current session
Machine needs to be on?	No	Yes	Yes
Access to local files?	No (fresh repo clone)	Yes	Yes
Trigger types	Schedule, API, GitHub events	Schedule (hourly/daily/weekly)	Fixed or adaptive interval
Minimum interval	1 hour	1 minute	1 minute
Survives restart?	Yes	Yes	No (7-day max)
Daily run limits	Pro: 5, Max: 15, Team: 25	No published cap	50 per session
Setup complexity	Web UI or `/schedule`	Desktop app	One command

When to use Routines

Routines are the right choice when the work should happen whether or not you're at your computer. They run on Anthropic's cloud infrastructure, which means they keep going when your laptop is closed, when you're asleep, or when you're on holiday.

Use Routines for:

Nightly code review — review all open PRs every evening and post summaries
Deploy verification — your CI/CD pipeline hits Claude's API endpoint after each deploy, Claude runs smoke tests
Issue triage — scan new issues every morning, apply labels, assign owners, post to Slack
Documentation drift — weekly scan of merged PRs to catch docs that reference changed APIs
PR-triggered review — Claude automatically reviews every new pull request via GitHub trigger

The trade-off: Routines clone your repo fresh each time. They can't see uncommitted changes, local environment variables, or tools installed on your machine. They work with what's in Git, not what's on your desk.

Pricing: Included with paid plans. Pro gets 5 runs/day, Max gets 15, Team/Enterprise gets 25. No per-run fee beyond your subscription.

When to use Desktop Scheduled Tasks

Desktop Scheduled Tasks are the right choice when you need access to your local machine — local files, local tools, local MCP servers. They run on your computer through the Claude Desktop app.

Use Desktop Tasks for:

Morning briefing — scan your local project folders every morning and summarize what changed
Security checks — run dependency audits using your local toolchain every few hours
Working with uncommitted files — tasks that need to read files you haven't pushed yet
Local MCP servers — jobs that use locally-configured connectors or on-machine API keys
Minute-level precision — the minimum interval is 1 minute vs Routines' 1-hour minimum

The trade-off: Your computer and the Claude Desktop app must stay on. If your machine sleeps, runs get skipped. It will catch up with the single most recent missed run within seven days, but that's it — if you missed five runs while sleeping, you only get one catch-up.

Pricing: No additional per-run fees. Runs within your normal subscription usage.

When to use /loop

/loop is the right choice for temporary, session-scoped monitoring during active work. It's the quickest to set up — literally one command — but it doesn't survive past your current session.

Use /loop for:

Deployment monitoring — watch a deploy for errors every 5 minutes while you're working
CI polling — check if your build passed every few minutes during active coding
PR discussion tracking — monitor comments on a PR during an active review session
Timed reminders — "remind me in 30 minutes to check the migration"
Adaptive monitoring — increase check frequency when errors spike, slow down when things stabilize

The trade-off: Maximum lifetime is 7 days. Maximum 50 concurrent tasks per session. If you restart Claude Code, your loops are gone. No persistence whatsoever.

Pricing: No additional fees. Just part of your session usage.

The decision flowchart

Here's how to pick the right one in 30 seconds:

1. Does it need to run when your laptop is closed?

Yes → Routines
No → keep going

2. Does it need access to local files, tools, or MCP servers?

Yes → Desktop Scheduled Tasks
No → keep going

3. Is it temporary monitoring during an active work session?

Yes → /loop
No → probably Routines (default to cloud when in doubt)

4. Does it need to run more frequently than once an hour?

Yes → Desktop Scheduled Tasks or /loop (Routines minimum is 1 hour)
No → Routines

Real-world example: the same task, three ways

Let's say you want to check for failing tests in your project every day.

As a Routine: Set up a cloud routine with a daily schedule trigger. It clones your repo, runs the test suite, and posts results to Slack. Works even if you're on vacation. But it can only test what's been committed.

As a Desktop Task: Configure a daily task in Claude Desktop. It runs tests against your local codebase — including uncommitted changes. Great for catching issues before you push. But your machine needs to be on.

As a /loop: Run /loop 30m run the test suite and alert me if anything fails. Perfect while you're actively developing a feature and want continuous feedback. But it disappears when you close the session.

Same goal, three different approaches — each with its own strengths.

What about GitHub Actions?

You might be wondering: why not just use GitHub Actions for all of this?

GitHub Actions are great for deterministic, scripted CI/CD workflows — lint, test, build, deploy. They're cheap ($0.002-$0.006 per runner minute) and free for public repos.

But Claude's automation modes do something GitHub Actions can't: reason. A GitHub Action runs a fixed script. A Claude Routine reads your code, understands context, makes judgment calls, and writes responses that adapt to what it finds. That's the difference between "run this linter" and "review this PR like a senior engineer would."

Use GitHub Actions for mechanical tasks. Use Claude's automation for tasks that need thinking.

Limitations worth knowing

A few gotchas that aren't obvious from the marketing:

Routines clone fresh every time. They don't remember state between runs. Each run starts from a clean repo clone. If you need state persistence, you'll need to store it somewhere (a file in the repo, an external service, etc.).
GitHub-triggered Routines don't reuse sessions. Each matching event starts a brand new, independent session. Two PR updates = two separate sessions, not one ongoing conversation.
Desktop Tasks only catch up once. If your machine was off and missed 5 scheduled runs, you get one catch-up run — not five.
/loop has a hard ceiling. Maximum 50 concurrent loops per session, maximum 7-day lifetime. Plan accordingly.
Routines act as you. Commits carry your GitHub username, Slack messages use your account. There's no separate "bot" identity.

The bottom line

You don't need to pick just one. Most workflows benefit from combining them:

Routines handle your always-on, cloud-based automation (PR reviews, deploy checks, issue triage)
Desktop Tasks handle your local, machine-dependent work (morning briefings, local security scans)
/loop handles your in-the-moment monitoring during active development

Start with whichever matches your most pressing need. You can always add the others later.