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 one axis that matters more than the others: where the work runs. /loop runs in your terminal, a Cowork scheduled task runs on your own computer inside the desktop app, and a Routine runs in Anthropic's cloud. Everything else — who it's for, what can trigger it, how long it survives — follows from that.

	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	Your computer (app must be open)	Anthropic's cloud
Runs with your machine off?	No — dies when you close the terminal	No — skips, then catches up when you wake the machine	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. The catch is that it runs on your machine, so it only fires when your computer is awake and the app is open. Miss the window and it runs on the next wake instead.

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 run while your computer is off or react to an event 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 run unattended, or fire when something happens." A Routine. Because Routines run in Anthropic's cloud, they don't care whether your laptop is open, and 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 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, on one machine. 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 your computer being awake, and sharing a loop across a team is clunkier than you'd expect. Design around it: put the loop on the machine and 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-and-on-your-machine goes to a scheduled task, iterate-until-done goes to /loop, unattended-or-event-driven goes to a Routine.

FAQ

Published: July 2026. Product names and limits (the /loop expiry window, the scheduled-task local-run requirement, and Routine triggers) were verified against Anthropic's documentation on the publish date; these surfaces 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?