Claude Scheduled Tasks: Set It Once, Let Claude Handle It Forever

What scheduled tasks are (and the 3 ways to use them)

Scheduled tasks let you describe a task once, pick how often it should run, and Claude handles it automatically. Think of it like a cron job, but instead of running a shell script, you're running Claude.

There are three different ways to schedule tasks across the Claude ecosystem. Each works differently and fits different workflows:

Method 1: Cowork scheduled tasks (Claude Desktop)

This is the most user-friendly approach. Each scheduled task spins up its own Cowork session with access to every tool, plugin, and MCP server you have connected — web search, Slack, Gmail, Google Drive, whatever you've set up.

/schedule

Method 2: Claude Code CLI (/loop and cron)

If you live in the terminal, Claude Code has built-in scheduling directly from the command line. There are two flavors: the /loop command for quick recurring tasks, and natural language reminders for one-shot timers.

The /loop command

The fastest way to set up a recurring check. Just tell Claude what to do and how often:

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

/loop check the build every 2 hours

/loop 20m /review-pr 1234

Interval syntax: s (seconds), m (minutes), h (hours), d (days). If you omit the interval, it defaults to every 10 minutes.

Natural language reminders

For one-shot tasks, just tell Claude when:

remind me at 3pm to push the release branch

in 45 minutes, check whether the integration tests passed

Full cron expressions

Under the hood, Claude Code uses standard 5-field cron expressions. You can ask Claude to create one with a specific cron schedule if you need precise control. All times are in your local timezone, not UTC.

Some things to know about the CLI scheduler:

• Tasks fire between your turns — never mid-response. If Claude is busy, the task waits.
• Max 50 scheduled tasks per session
• Recurring tasks auto-expire after 3 days — you'll need to recreate them
• Supports wildcards, ranges, steps, and comma-separated values — but not extended cron syntax like L, W, or day name aliases

Method 3: GitHub Actions (cloud, always-on)

This is the only truly "set it and forget it" approach. Tasks run on GitHub's infrastructure — no open terminal, no desktop app, no machine that needs to stay awake. It survives restarts, runs unattended, and works on a real cron schedule.

/install-github-app

name: Daily Code Review
on:
  schedule:
    - cron: '0 9 * * 1-5'  # Weekdays at 9 AM UTC
  workflow_dispatch:        # Also allow manual triggers

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: anthropics/claude-code-action@v1
        with:
          prompt: |
            Review all commits from the last 24 hours.
            Check for security issues, performance
            problems, and code quality. Open issues
            for anything that needs attention.
          max_turns: 10
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}

Use cases that actually matter

Here's where scheduled tasks go from "cool feature" to "I can't work without this." These are the workflows that save real time.

Morning briefing

Best with: Cowork (daily) · Needs: Slack, Gmail, Calendar MCP servers

Have Claude summarize everything that happened overnight — Slack messages, emails, calendar events, GitHub notifications. You wake up, open Claude, and there's a clean briefing waiting for you instead of 47 unread notifications.

Summarize everything from the last 12 hours:

- Slack: highlight any messages that mention me or need a response
- Email: summarize new emails, flag anything urgent
- Calendar: list today's meetings with context on what each one is about
- GitHub: any new PRs, issues, or comments on my repos

Format as a briefing I can scan in 2 minutes. Put urgent items at the top.

Weekly report generation

Best with: Cowork (weekly) · Needs: Google Drive, project management MCP servers

Compile data from connected tools into a formatted summary every Friday. Pull from Google Drive, spreadsheets, project management tools, or anything connected via MCP. The report is ready before your standup.

Generate my weekly status report:

- Pull all completed tasks from my project board this week
- Summarize key metrics from the analytics dashboard
- List any blockers or risks
- Draft next week's priorities based on what's in the backlog

Save as a formatted document in my Weekly Reports folder.

Automated code review

Best with: GitHub Actions (weekdays) or Claude Code CLI (/loop)

Have Claude review the last 24 hours of commits every morning. It checks for security issues, performance problems, code quality regressions, and anything that doesn't match your coding standards — then opens issues for what needs attention.

Review all commits from the last 24 hours across all active branches.

Check for:
- Security vulnerabilities (injection, auth issues, exposed secrets)
- Performance regressions (N+1 queries, missing indexes, large payloads)
- Code quality (duplicated logic, missing error handling, unclear naming)
- Test coverage gaps for new functionality

Open a GitHub issue for each finding with severity, location, and suggested fix.

Competitor and industry monitoring

Best with: Cowork (weekly) · Uses web search

Track competitors, industry news, or specific topics on a daily or weekly cadence. Claude searches the web, compiles findings, and highlights what's changed since the last run.

Research and summarize the latest news about [your competitors or industry]:

- New product launches or feature updates
- Pricing changes
- Notable blog posts, announcements, or press coverage
- Social media sentiment shifts

Compare to last week's report and highlight what's new.

Dependency and security audit

Best with: GitHub Actions (weekly, Mondays)

Schedule a weekly scan of your codebase for outdated dependencies, known vulnerabilities, hardcoded secrets, and unsafe patterns. Claude opens PRs or issues with fixes.

Run a security and dependency audit:

- Check for outdated packages with known CVEs
- Scan for hardcoded secrets, API keys, or credentials
- Review authentication and authorization patterns
- Check for unsafe input handling or injection vectors
- Flag any TODO/FIXME/HACK comments related to security

For each finding, open a GitHub issue with severity level and remediation steps.
For simple fixes (dependency bumps), open a PR directly.

File cleanup and organization

Best with: Cowork (weekly)

Set a weekly task that scans a folder (your Downloads, Desktop, or project directory), categorizes files, moves them to the right places, and flags anything that looks like it should be deleted.

Scan my ~/Downloads folder:

- Categorize files by type (documents, images, code, installers, etc.)
- Move documents to ~/Documents, images to ~/Pictures
- Flag any files older than 30 days that might be safe to delete
- List everything you moved and why

Financial tracking

Best with: Cowork (daily) · Needs: Stripe MCP server

Connect to Stripe (via MCP) and get automated revenue reports. Track subscription changes, flag unusual activity, and generate financial summaries on a schedule.

Pull my Stripe data for the past 24 hours:

- Total revenue and transaction count
- New subscriptions vs. cancellations
- Any failed payments or disputes
- Compare to the same day last week

Format as a dashboard-style summary.

Invoice and receipt organization

Best with: Cowork (weekly) · Needs: Gmail MCP server

Have Claude scan your email or a specific folder for receipts and invoices, categorize them by expense type, and compile them into a spreadsheet. Run it weekly or monthly depending on volume.

Scan my email for any receipts or invoices from the past week:

- Extract vendor name, date, amount, and category
- Add each to my expense tracking spreadsheet
- Flag any subscriptions I might not be using
- Calculate total spending by category

Content performance tracking

Best with: Cowork (weekly) · Uses web search + MCP servers

If you're a creator, schedule a daily or weekly task that pulls your analytics and tells you what's working. YouTube views, newsletter open rates, social engagement — whatever metrics you care about.

Pull my content analytics for the past week:

- Newsletter: open rate, click rate, new subscribers, unsubscribes
- YouTube: views, watch time, new subscribers, top performing video
- Twitter/X: impressions, engagement rate, follower growth

Identify the top performing piece of content and explain why it worked.
Suggest 3 content ideas based on what's resonating.

Subscription audit

Best with: Cowork (monthly) · Needs: Gmail MCP server

Run this monthly. Claude scans your email for subscription confirmations, recurring charges, and trial sign-ups — then flags anything you might have forgotten about.

Audit my subscriptions:

- Scan email for recurring payment confirmations from the past 30 days
- List every active subscription with name, cost, and billing date
- Flag any I haven't used in the past 2 weeks
- Calculate total monthly subscription spend
- Recommend which ones to cancel based on usage

TODO cleanup

Best with: GitHub Actions (weekly, Fridays) or Claude Code CLI (/loop)

Every codebase accumulates TODO comments. Schedule a weekly sweep that finds them all, prioritizes which ones to address, and optionally opens issues for the most important ones.

Find all TODO, FIXME, HACK, and XXX comments in the codebase.

For each one:
- Classify as high/medium/low priority
- Check if it's already tracked in an issue
- Estimate effort to resolve

Create a summary of the top 5 most important ones and open GitHub issues
for any high-priority items that aren't already tracked.

Deployment monitoring

Best with: Claude Code CLI (/loop 5m)

After shipping a deploy, set a loop to monitor it. Claude checks the status every few minutes and alerts you when it's done — or if something breaks.

/loop 5m check the deployment status for production. If it's finished,
tell me whether it succeeded or failed. If failed, pull the error logs
and summarize what went wrong.

MCP servers: where it gets powerful

Without MCP servers, your scheduled tasks can only work with local files and web searches. With them, Claude can interact with basically anything — Gmail, Google Calendar, Slack, Notion, Stripe, GitHub, and hundreds of other services.

MCP (Model Context Protocol) servers are what connect Claude to external tools. Each one gives Claude the ability to read from and write to a specific service. When you set up a scheduled task in Cowork, it inherits every MCP server you've connected.

This is what turns scheduled tasks from "summarize a folder" to "pull my Slack messages, cross-reference with my calendar, check my email, and give me a morning briefing."

Editing tasks on disk

Every Cowork scheduled task is stored as a file on your machine. You can edit the prompt directly without going through the UI:

~/.claude/scheduled-tasks/<task-name>/SKILL.md

The file uses YAML frontmatter for the task name and description, with the prompt as the body. Changes take effect on the next run.

This is useful when you want to version control your prompts, make quick edits without opening Claude Desktop, or copy tasks between machines.

Limitations and gotchas

Cowork: your computer must be awake

This is the big one for Cowork. Scheduled tasks only run while your computer is awake and the Claude Desktop app is open. If your machine is asleep or the app is closed, Cowork skips the task — then runs it automatically when you wake up or reopen the app.

For most people this is fine — your morning briefing runs when you open your laptop. But if you need tasks to run at exact times regardless, adjust your power settings to prevent sleep, run on a cloud machine, or use GitHub Actions.

CLI tasks are ephemeral

Claude Code CLI tasks are session-scoped — close the terminal and they're gone. Recurring tasks also auto-expire after 3 days, so you'll need to recreate long-running ones. If Claude is mid-response when a task fires, it queues and runs after the current turn finishes.

Cowork: no granular time control

Cowork's built-in frequencies are hourly, daily, weekly, and weekdays. You can't set a task to run at exactly 9:47 AM or every third Tuesday. For precise scheduling, the CLI gives you full cron syntax, and GitHub Actions gives you cron on cloud.

CLI: timing has built-in jitter

Claude Code adds small timing jitter to scheduled tasks — up to 10% of the interval for recurring tasks (capped at 15 minutes). One-shot tasks at the top or half hour can fire up to 90 seconds early. This is by design and generally doesn't matter, but be aware if exact timing is critical.

GitHub Actions: costs money

GitHub Actions scheduled tasks consume both Actions minutes and Anthropic API tokens. Set max_turns on every workflow to prevent runaway jobs, and consider using a faster model for simple tasks to keep costs down.

Pro plan usage limits

Cowork scheduled tasks are available on all paid plans, but Pro users will hit usage caps faster since each scheduled task runs a full Cowork session. If you're scheduling multiple daily tasks, Max gives you more headroom.

Tips for better scheduled tasks

Test manually first

Before scheduling anything, run the prompt in a regular Cowork task. Make sure it produces the output you want, that all MCP connections work, and that the format is right. Then schedule it.

Be specific in your prompts

Scheduled tasks don't have you there to clarify. Write your prompt as if you're handing instructions to someone who can't ask questions. Include the output format, what to prioritize, where to save results, and what to do if something is missing.

Start with one task

Don't set up 10 scheduled tasks on day one. Start with one — a morning briefing is the best starting point. Get it dialed in, refine the prompt, then add more tasks as you see what's useful.

Use "on demand" for semi-regular tasks

Not everything needs to be fully automated. Cowork's "on demand" frequency saves your prompt and configuration so you can trigger it with one click — perfect for tasks you run often but not on a strict schedule.

Match the method to the need

Quick terminal check while you're coding? Use /loop. Daily personal automation? Use Cowork. Repo-level CI/CD that needs to be bulletproof? Use GitHub Actions. Don't force one method to do everything.

Review and iterate

Check the output of your scheduled tasks for the first week. You'll almost always want to tweak the prompt — maybe you want more detail in one section, a different format, or additional data sources. Edit the SKILL.md file directly for quick changes.

Choose the right model

Not every task needs the most powerful model. A simple file cleanup or data summary might work fine with a faster model, saving your heavy-duty model usage for tasks that need deeper reasoning. Match the model to the complexity of the task.

The bottom line

Scheduled tasks turn Claude from something you use reactively into something that works for you in the background. The setup takes 30 seconds. The value compounds every single day.

The whole point is this: if you do something more than twice, Claude should be doing it for you.