How to Use Claude Loops for Business: /loop vs Scheduled Tasks vs Routines

Anthropic shipped three different "recurring Claude" features in about three months, under three different names, and the internet has been arguing about which is which ever since. This is the plain-English version, written by people who run all three.

The map: /loop vs scheduled tasks vs Routines

The three surfaces differ on two axes that matter more than the rest: who it's for, and what can trigger it. /loop lives in the terminal — a developer tool, goal-driven and short-lived. A Cowork scheduled task is the non-developer path, set in plain language and fired on a clock; since the July 2026 cloud-session expansion it runs cloud-hosted, so it no longer needs your machine awake. A Routine is the developer path — also cloud-hosted, but triggerable by an API call or a GitHub event, not just the clock. Everything else follows from those two axes.

	Claude Code /loop	Cowork scheduled tasks	Claude Code Routines
Who it's for	Developers, in the terminal	Non-developers, in the desktop app	Developers who need always-on
Where it runs	Your terminal session	Anthropic's cloud (set up in the desktop app)	Anthropic's cloud
Runs with your machine off?	No — dies when you close the terminal	Yes — cloud-hosted since July 2026	Yes — fully hosted
What triggers it	An interval and/or a goal condition	A schedule (calendar cadence)	A schedule, an API call, or a GitHub event
How long it lasts	About three days, then you restart it	Ongoing, on its cadence	Ongoing, until you turn it off
Best for	Iterate-until-done, short polling	Recurring reports and checks a non-coder can set up	Production loops that must run unattended or react to events

Read the table and the decision almost makes itself. If you can't or don't want to open a terminal, /loop and Routines aren't your on-ramp — they live inside Claude Code, the developer tool. The one built for you is the Cowork scheduled task: you describe the job in plain language inside the desktop app, pick a cadence, and it runs. Since the July 2026 cloud-session expansion it runs cloud-hosted, so it fires on schedule even with your computer asleep or closed — the old "the app has to stay open" limit is gone. (From October 6, 2026, new Cowork tasks on Pro and Max plans run in the cloud as well; work that touches files on your computer still needs the desktop app open.)

The Ralph loop: where this all came from

Before Anthropic shipped any of these commands, the technique already existed as folklore: the "Ralph" loop. Named after the Simpsons character, it's the crudest possible version of the idea — put an AI agent in a plain shell loop and let it run the same instruction over and over until the work is done. Geoffrey Huntley popularized it in late 2025, and it's the honest ancestor of every polished feature in the table above.

A Ralph loop is worth understanding because it makes the whole category legible. Strip away the product names and a "loop" is just this: a goal, an action, a check on the result, and a decision to go again or stop. That's it. The dumb version has no memory and no judgment; it re-reads its instructions each pass and grinds forward. It's genuinely useful for narrow, verifiable work ("keep fixing until every test passes") and genuinely dangerous for anything open-ended, because a dumb loop with no stop condition will happily run forever and bill you for the privilege. Anthropic's three features are, in effect, the Ralph loop with guardrails, scheduling, and a UI — which is exactly why the community still uses "loop" as the umbrella word even though no Anthropic product is named that.

Which surface for which job

Pick the surface by the shape of the job, not the hype: recurring report or check goes to a Cowork scheduled task, a codebase chore that should iterate until it's right goes to /loop, and anything that must react to an event — not just fire on a clock — goes to a Routine. Here's the same logic as a set of if-thens, with a real example of each from our own operation.

"I want a report or a check on a schedule." Cowork scheduled task. This is 80% of what a non-developer actually needs: a Monday-morning pipeline summary, a nightly inbox triage, a weekly analytics read. You set it up by talking to Claude in the desktop app. Our client-facing conversion review is one of these, and the person receiving it never touches a terminal.

"I want it to work on my code until a condition is true." /loop. This is the developer's iterate-until-done tool: /loop until: all tests pass or /loop every 30m until: the build is green. It's a short-lived, goal-seeking sprint inside a coding session, not a standing service. It expires after about three days by design, which tells you it was never meant to be your production automation.

"It has to fire when something happens, not just on a clock." A Routine. Cowork scheduled tasks now run unattended in the cloud too, so "runs while I'm away" is no longer the dividing line — the trigger is. Because Routines run in Anthropic's cloud, they can be triggered three ways: on a schedule, by an API call (an HTTP request to a per-routine endpoint), or by a GitHub event like a pull request. That event-trigger ability is the one real capability the Cowork scheduled task still doesn't have — which matters more than it sounds, and we'll come back to it.

What we actually run

We run five production loops today; the oldest has run every day for about 90 days, and the mix spans all three surfaces plus a custom scheduler. The point of listing them isn't to impress — it's to show which surface each job naturally landed on, because that mapping is the real lesson.

The SEO/AEO engine (daily, scheduled task). The flagship, and the system that published the page you're reading. Every morning it pulls our Google Search Console data, runs live checks on the AI Overview answers we're trying to be cited in, ships the low-risk fixes itself, confirms Google actually re-crawled what we asked it to, and posts one consolidated report to Slack. It branches by weekday — light checks most days, a full deep dive on Friday — and it's a scheduled task because it needs to touch our own accounts and files, and because a human is nearby to catch the judgment calls. In its first 90 days it drove roughly 850% search-visibility growth and earned named citations inside Google's AI Overviews. The full write-up is in our 90-day field report, and the build is documented as a case study.

The client CRO deep-dive (weekly, scheduled task). Every week a loop reads a client's product analytics, runs a conversion-and-reliability review, and posts a prioritized findings brief. The client experiences it as a service — a weekly analyst who never skips a week — which is the whole thesis behind service as software: a loop pointed at a client's problem is a deliverable, not a demo.

The bookkeeping loop (monthly, scheduled task). The relatable one. It reads the books through an accounting connector, reconciles transactions, flags what doesn't categorize cleanly, and preps the close packet a human reviews. Back-office loops are the least glamorous and the most obviously worth it.

The re-index verification loop (daily, custom). When the SEO loop edits a page it asks Google to re-crawl, but a request isn't a result — so a small state machine tracks every submission and checks back three days later: re-crawled, close it; ignored, retry once; ignored twice, stop and escalate to a human. It's the "loop that watches the loop," and it exists because we learned the expensive way that "submitted" and "indexed" are different facts.

Notice the pattern: four of our five are Cowork scheduled tasks, not /loop or cloud Routines. That's not an accident. Most business loops are calendar-shaped and need to touch your own accounts and files, which is exactly what the scheduled task is built for.

The traps nobody puts in the tutorials

Four things will bite you, and none of them show up in the launch-day demos: cost at cadence, the no-event-triggers limit on scheduled tasks, the one-account wall, and missing stop conditions. We've hit all four. Here's each, plainly.

Cost at daily cadence. The horror stories are real — there's a whole backlash thread calling the loop trend "a financial nightmare" — and they almost all share one anatomy: a metered API, an unbounded loop, and no stop condition. Our own five loops run on a fixed-price $200/month Claude subscription plus roughly $2–$5/month of external data calls, because scheduled runs are bounded and spread across the day instead of hammering a metered endpoint. The rule: bound the runs, cap the retries, and prefer subscription compute over per-token API billing wherever the work allows it. Do that and the 90th run costs the same as the first.

Scheduled tasks can't react to events — only the clock. A Cowork scheduled task fires on a cadence: every day at 8, every Monday, the first of the month. It cannot fire "when a new lead comes in" or "when this file changes." If you need event-driven behavior, that's precisely what a Routine's API and GitHub triggers are for — and it's usually the moment a business loop graduates from the desktop app to the cloud, which typically means bringing in a developer.

The one-account wall. This is the trap that surprises people most. Scheduled tasks and the connectors they use run under one signed-in Claude account. There's no clean "service account" that a task runs as independent of you. In practice that means your automation is tied to your login, and sharing a loop across a team is clunkier than you'd expect. Design around it: put the loop on the account that should own it, and don't assume it can quietly act on behalf of the whole company.

Missing stop conditions. A loop without a termination rule is the original sin of the whole category — it's the first thing Addy Osmani flagged when he coined "loop engineering," and it's the cause of most of the cost horror stories. Every loop needs both a per-run stop ("this run is done when the checklist is complete," not "when the model feels finished") and a per-action stop ("retry this twice, then escalate to a human"). An agent that retries an external service forever isn't just expensive; it's the kind of behavior that gets your API access throttled.

Claude vs ChatGPT scheduled tasks

Both Claude and ChatGPT can now run tasks on a schedule, and for simple recurring prompts they're comparable; the difference shows up the moment the job needs to touch your real systems and take actions. ChatGPT's scheduled tasks (relaunched as a dedicated feature in mid-2026) are strongest at recurring prompts: send me a morning briefing, remind me about X, summarize this feed. Genuinely useful, and if that's all you need, use whichever assistant you already pay for.

Where Claude's surfaces pull ahead for business is depth of action. A Cowork scheduled task can be wired to your files, your CMS, your analytics, and your Slack, and it can change things under a permission policy you set — not just message you. And Claude Code Routines add the always-on cloud execution and event triggers that turn a scheduled prompt into a standing service. If your recurring job is really "tell me something," it's a coin flip. If it's "do something, to my systems, on a schedule, safely," that's the Claude scheduled-task-or-Routine lane.

How to start: one loop, this week

Start with one Cowork scheduled task, on one function, that produces one report and changes nothing without your say-so. Not five loops, not an "AI employee." Pick the recurring job where the data already lives in a system Claude can reach — analytics, a spreadsheet, your inbox — and where the weekly work is real but rule-shaped. Set it to run report-only for two or three weeks. You're testing two things at once: whether its reads are accurate, and whether its judgment about what matters is earning your trust.

Then, and only then, grant it the narrowest permission that would actually save you time, with an explicit list of what it may touch. Widen the list as it earns it. That supervised-first, autonomy-earned progression is how every loop we run went from demo to department — and it's the same shape whether you build it as a Cowork scheduled task or, later, graduate it to a cloud Routine.

If you want the bigger-picture version of why these matter — the anatomy of a loop that runs a business function, with the numbers and the failure modes — we wrote that up separately in business loops. And if you'd rather just see where a loop would pay off in your own operation, that's what our Revenue Audit is for. New to Cowork entirely? Start with how to use Claude Cowork and the difference between Cowork and Claude Code.

One honest caveat: the vocabulary here is only a few months old and still moving. Anthropic may rename or merge these surfaces, and the exact expiry windows and seat rules change. The durable part isn't the product name — it's the decision: on-a-schedule goes to a scheduled task, iterate-until-done goes to /loop, event-driven goes to a Routine.

Frequently asked questions

What is a Claude loop?

A Claude loop is Claude running a task repeatedly toward a goal instead of answering a single prompt: it takes an action, checks the result through tools, adjusts, and continues until a stop condition is met. In Claude Code the /loop command does this in your terminal for up to about three days; Claude Cowork's scheduled tasks and Claude Code's cloud Routines run the same idea on a schedule.

How do I make Claude run on a schedule?

If you are not a developer, use Claude Cowork scheduled tasks: open the Claude desktop app, describe the recurring job in plain language, and set a cadence. Since the July 2026 web-and-mobile expansion, scheduled tasks run cloud-hosted and fire on schedule even with your computer asleep or closed. Developers who want a loop triggered by an API call or a GitHub event can use a Claude Code Routine, which also runs in Anthropic's cloud.

What is the difference between Claude scheduled tasks and Routines?

Both now run in Anthropic's cloud, so both keep running with your laptop closed. The difference is the path and the trigger surface: Cowork scheduled tasks are the non-developer path, set up in plain language in the desktop app and fired on a time schedule. Claude Code Routines are the developer path, defined in code and triggerable by a schedule, an API call, or a GitHub event. Choose scheduled tasks for recurring plain-language jobs; choose Routines when you need programmatic or event triggers.

Can Claude run tasks without me being there?

Yes. Since the July 2026 cloud-session expansion, a Cowork scheduled task runs cloud-hosted and unattended and no longer needs your machine awake. A Claude Code Routine likewise runs fully in the cloud. Either way, we recommend an explicit judgment gate: a written list of low-risk actions the loop may take alone, with everything else queued for a human.

What is a Ralph loop?

A Ralph loop is the folk technique of running an AI agent in a plain shell loop that repeats the same instruction until the work is done, popularized by Geoffrey Huntley in late 2025. It is the crude ancestor of Claude's /loop, scheduled tasks, and Routines: same core idea (goal, action, check, repeat) without the scheduling, memory, or guardrails the products add.

How much do Claude loops cost to run?

Bounded, scheduled loops are cheap. Our five production loops run on a $200/month fixed Claude subscription plus roughly $2 to $5 a month in external data-API calls. Cost problems almost always come from unbounded loops hammering a metered API with no stop condition. Bound the runs, cap retries, and prefer subscription compute, and the marginal cost of each additional run is close to zero.

Claude vs ChatGPT scheduled tasks: which is better for business?

For simple recurring prompts (a daily briefing, a reminder), they are comparable; use whichever assistant you already pay for. For business automation that must touch your real systems and take actions under a permission policy, Claude's Cowork scheduled tasks and Claude Code Routines go deeper, because they connect to your files, tools, and workflows and can change things, not just message you.

Published: July 2026. Updated: September 2026 to reflect that Cowork scheduled tasks now run cloud-hosted (the July 2026 web-and-mobile expansion), so they no longer require your machine to stay awake. Product names and limits (the /loop expiry window, scheduled-task cloud execution, and Routine triggers) change fast, so check the current docs before you build.

Related: Business loops: loops that run a business, not code · How to use Claude Cowork · Claude Cowork vs Claude Code · What is Claude Cowork? · Claude Cowork pricing · What is an agentic website? · Can an autonomous AI agent run a business on its own? It made $0