Claude Code's /loop Command: Scheduled Tasks, Cron Jobs, and Autonomous Agents

What /loop Does

Claude Code 2.1.71, released on March 7, 2026, added a /loop command that turns your terminal into a lightweight task scheduler. You give it an interval and a prompt, and Claude runs that prompt on repeat in the background while your session stays open.

/loop 5m check if the deployment finished and tell me what happened

That’s it. Claude parses the interval, converts it to a cron expression, schedules the job, and confirms what it set up. Every five minutes, it runs your prompt as if you’d typed it yourself.

The feature shipped alongside cron scheduling tools (CronCreate, CronList, CronDelete) that give you finer control when you need it. But /loop is the entry point most people will use.

Syntax

The interval can go at the start, at the end with an “every” clause, or be left out entirely (defaults to every 10 minutes).

Form	Example	What it does
Leading interval	`/loop 30m check the build`	Every 30 minutes
Trailing “every”	`/loop check the build every 2h`	Every 2 hours
No interval	`/loop check the build`	Every 10 minutes (default)

Supported time units: s (seconds), m (minutes), h (hours), d (days). Since the underlying scheduler uses cron with one-minute granularity, seconds get rounded up to the nearest minute. Intervals that don’t divide evenly, like 7m or 90m, get rounded to the nearest clean interval and Claude tells you what it picked.

Looping Over Other Commands

The prompt you schedule can itself be a slash command. So you can chain /loop with any skill or command you already have:

/loop 20m /review-pr 1234

Every 20 minutes, Claude runs /review-pr 1234 as if you’d typed it. This is where things get interesting. Any workflow you can express as a slash command becomes something you can run on a schedule.

One-Shot Reminders

You don’t need /loop for one-time tasks. Just ask Claude in natural language:

remind me at 3pm to push the release branch

in 45 minutes, check whether the integration tests passed

Claude schedules a single-fire task using a cron expression, confirms the fire time, and deletes the task after it runs.

Managing Tasks

Ask Claude directly:

what scheduled tasks do I have?

cancel the deploy check job

Under the hood, three tools handle everything:

Tool	What it does
`CronCreate`	Schedule a new task with a 5-field cron expression
`CronList`	List all tasks with IDs, schedules, and prompts
`CronDelete`	Cancel a task by its 8-character ID

A session holds up to 50 scheduled tasks at once.

How It Works Under the Hood

The scheduler checks every second for due tasks and enqueues them at low priority. Tasks fire between your turns, not while Claude is mid-response. If Claude is busy when a task comes due, the prompt waits until the current turn finishes.

All times use your local timezone. A cron expression like 0 9 * * * means 9am wherever you are, not UTC.

Jitter. To prevent every session from hitting the API at the same moment, the scheduler adds a small deterministic offset. Recurring tasks can fire up to 10% of their period late, capped at 15 minutes. An hourly job might fire anywhere from :00 to :06. One-shot tasks near the top or bottom of the hour can fire up to 90 seconds early. The offset is derived from the task ID, so it’s consistent.

Three-day expiry. Recurring tasks automatically expire after 72 hours. The task fires one last time, then deletes itself. This caps how long a forgotten loop can run up your bill. If you need something longer, cancel and recreate it, or use Desktop scheduled tasks for durable scheduling.

No catch-up. If a task’s scheduled time passes while Claude is handling a long request, it fires once when Claude becomes idle. It doesn’t try to fire once per missed interval.

Cron Expressions

If you want precise control, CronCreate accepts standard 5-field cron expressions: minute hour day-of-month month day-of-week.

Expression	Meaning
`/5 * * *`	Every 5 minutes
`0 * * * *`	Every hour on the hour
`0 9 * * *`	Daily at 9am
`0 9 * * 1-5`	Weekdays at 9am
`30 14 15 3 *`	March 15 at 2:30pm

All fields support wildcards (*), single values (5), steps (*/15), ranges (1-5), and comma-separated lists (1,15,30). Extended syntax like L, W, or name aliases (MON, JAN) isn’t supported.

Practical Use Cases

Deployment babysitting. Start a deploy, then:

/loop 2m check the deploy status on staging and let me know when it's healthy

Walk away. Claude will check every two minutes and report back when something changes.

PR monitoring. Waiting on CI?

/loop 10m check if CI passed on PR #482 and summarize any failures

Build watching. Running a long compilation or training job?

/loop 5m check if the build process in tmux session "train" has finished

Periodic code review. On a team with active PRs:

/loop 1h /review-pr 1234

Self-testing loops. Run tests, fix failures, repeat:

/loop 15m run the test suite and fix any failing tests

This last pattern is where /loop connects to a bigger idea.

Auto-bug-fixing. Thariq Shihipar from Anthropic described checking error logs every few hours, with Claude Code automatically creating pull requests for fixable bugs. Boris Cherny, who created Claude Code, mentioned auto-monitoring PRs with self-fixing and generating morning Slack summaries.

/loop vs. Ralph Wiggum

The Ralph Wiggum Technique (Geoffrey Huntley, mid-2025) and /loop look similar but solve different problems.

Ralph Wiggum iterates toward task completion. One task, many attempts. It intercepts Claude’s exit, re-feeds the same prompt, and lets Claude self-correct until the job is done. It’s a construction crew: keep building until it’s finished.

/loop polls on a schedule. Recurring checks, periodic monitoring, status updates. It’s a security camera: keep watching and report when something changes.

Anthropic observed the community using Ralph Wiggum and factored out the recurring-execution pattern as a platform primitive. They shipped /loop addressing the most common use case (scheduled polling) rather than absorbing the full autonomous-iteration behavior. Ralph Wiggum is still available as a plugin in the Claude Code repo for the iterate-until-done workflow.

Source: From Ralph Wiggum to /loop: The Absorption Continues

The Autoresearch Connection

The timing of /loop’s release (March 7) and Karpathy’s autoresearch release (also March 7) wasn’t coordinated, but the overlap is telling. Both address the same fundamental idea: set up an AI agent with clear instructions and an evaluation criteria, then let it iterate autonomously.

Autoresearch has a specific evaluation metric (val_bpb) and a strict keep-or-discard protocol. /loop is general-purpose. It’s up to you to define what “check” means and what to do with the results. That makes it more flexible but less rigorous for research workflows.

Glen Rhodes characterized /loop as a “category shift” that transforms AI coding tools from synchronous query tools into asynchronous agents. Both /loop and autoresearch point in the same direction: humans define strategy and success criteria, agents execute autonomously.

Limitations

These are real constraints, not edge cases:

Session-scoped only. Everything dies when you close the terminal or exit Claude Code. No persistence across restarts.
Requires an active session. Tasks only fire while Claude Code is running and idle. This isn’t a daemon.
No offline scheduling. If you need unattended cron jobs, use GitHub Actions workflows with a schedule trigger or Desktop scheduled tasks.
API costs accumulate. A /loop 5m running for 8 hours is 96 prompts. Each prompt consumes tokens. On a Claude Pro subscription this eats into your usage allocation. On API billing, costs add up directly.
50 task limit. A single session can hold up to 50 scheduled tasks. For most workflows this is plenty, but building a complex multi-loop system could hit the cap.

Tips

Include a “stay silent” clause. If your loop checks something that rarely changes, add “stay silent if nothing changed” to reduce output noise. Otherwise you’ll get a wall of “everything looks fine” messages.

Watch the cost. A forgotten /loop 5m running for the full 3-day expiry window is about 864 prompt invocations. On API billing, that adds up. On a Max subscription the usage is included, but it still eats into your allocation. Be deliberate about intervals.

Context can degrade. After 6+ hours of accumulated conversation history, response quality may drop. For long-running monitoring, starting a fresh session and re-creating the loop periodically can help.

Be specific about “done.” A vague prompt like “check the deploy” can burn tokens without useful output. “Check if the staging URL returns 200 and the version header matches v2.4.1” gives Claude something concrete to evaluate.

CLI vs. Desktop vs. GitHub Actions

	CLI `/loop`	Desktop Scheduled Tasks	GitHub Actions
Persistence	Session only	Survives restarts	Cloud
Max duration	3 days	Indefinite	Indefinite
Missed-fire catch-up	No	Yes (7-day lookback)	Yes
Platform	All	macOS/Windows	Any
Best for	”Watch this for the next few hours"	"Run this every weekday at 9am”	Unattended CI/CD

Disabling It

If you’re in a shared environment or CI pipeline where you don’t want scheduled tasks:

export CLAUDE_CODE_DISABLE_CRON=1

This makes /loop and all cron tools unavailable. Any already-scheduled tasks stop firing.

The Bigger Picture

/loop is a small feature with large implications. It turns Claude Code from a tool you interact with into a tool that works alongside you. The obvious next step is combining /loop with hooks, MCP servers, and custom skills to build agent workflows that monitor, react, and iterate without constant human input.

Karpathy called it “programming the program.md.” With /loop, you’re doing the same thing inside Claude Code: writing prompts that direct an autonomous loop. The skill isn’t writing code anymore. It’s writing instructions that hold up when you’re not watching.