How do I know whether the task I've set up runs in the cloud or locally?
The most direct signal is whether you specified a working folder during setup. If you only selected connectors like Slack or Gmail without pointing the task at any folder on your computer, it gets classified as remote execution, unrelated to whether your computer is on. The moment you choose which folder the task should work in, you've tied it to your local machine, and it needs your computer awake to fire on time.
If you're not sure, the safest check is to look at that task's run history in the Scheduled tab — if it has completed on time even during a window when your computer wasn't on, that's a cloud task working as intended. If the execution time consistently lags behind the scheduled time, clearly waiting until you turn your computer on to catch up, that's a local task.
If I need a task that touches both cloud data and local files, how should I design for that hybrid case?
Under the current architecture, once a scheduled task is determined to need a local folder, the entire task falls under local execution rules, and your computer's power state affects it — there's no partial mode where some of it runs in the cloud and some locally. If your need genuinely spans both — say, aggregating data from a cloud drive and then writing the result into a local folder on your computer — the more practical approach is to split it into two tasks: a pure cloud task that handles the aggregation and content generation, storing the output somewhere accessible from your Claude account; and a separate local task that retrieves that output and writes it into the local folder, scheduled for a time you know your computer will be awake.
This split adds a bit of setup, but in exchange, the cloud portion becomes entirely immune to your computer's power state, and the part that genuinely needs a local environment is narrowed down to just the one step that actually requires it.
Could a cloud scheduled task fail because it can't find a certain folder?
No, because a cloud task is designed from the outset to never read folders on your computer — the resources it can reach are limited to connectors you've already set up (Slack messages, files in Google Drive, and so on) and files saved to your Claude account. That means a cloud task never attempts to access a local folder during execution, so there's no scenario where it "fails because it can't find a folder." That's the practical meaning behind the documentation's explicit note that a remote scheduled task can't be tied to a folder on your computer.
If you were expecting a cloud task to process a specific folder on your computer, you'd find that the setup interface simply won't let you attach that kind of task to a local path — that's not an unclear limitation, it's a path that was never designed to exist. Any need for a local folder has to go through a local task instead.
How does the local task "catch-up" mechanism differ from what most people assume — that everything missed still eventually gets done?
The biggest gap is that catch-up only covers the most recently missed run, not every missed instance in between. If your daily task misses three runs because your computer stayed off for three days straight, once the computer comes back online, the system typically only executes the most recent one — the two earlier missed instances aren't individually recovered. That's different from the common assumption that "the data still gets generated for those days, just delivered late"; the actual behavior is closer to "the runs from those intervening days simply disappear, leaving only the latest one."
For tasks that need an independent record for each day (a day-by-day financial roll-up, say), this gap can create data holes worth accounting for when designing a local task — for example, by scoping the task's content to "summarize the past N days" rather than assuming each day will produce its own separate, complete execution record.
The question of whether Claude Cowork scheduled tasks still run while your computer sleeps actually has two different answers online — an old one and a current one — and a lot of existing articles describe the old behavior, which can lead you astray. Anthropic's current help documentation is explicit: most scheduled tasks run remotely, so they fire on schedule even when your computer is asleep or the Claude Desktop app is closed. The one case where your computer's power state genuinely matters is when a task specifically needs a local folder or app on your machine.
By default, a scheduled task works with the connectors you've already set up (Slack, Google Drive, and so on) and files saved to your Claude account. That kind of task executes on Anthropic's servers, completely decoupled from whether your computer is on — even if your machine sleeps all night and the desktop app never opens, the task still runs at its scheduled time and the result shows up waiting for you in the Scheduled tab.
But if you configure a task with a specific working folder — asking Claude to read or write files in a folder on your computer — Anthropic's documentation is explicit that this kind of task can only run locally, and your computer needs to be awake with the desktop app open and connected when it fires. This distinction isn't a minor operational detail; the type of task decides from the start whether it runs in the cloud or locally, and the reliability profile of the two is not remotely the same.
If a task tied to a local folder misses its scheduled time because your computer was asleep, it doesn't just disappear — the next time your computer wakes and the desktop app reconnects, the system runs a catch-up for the most recently missed instance and skips anything missed before that. That means if your computer stays off for several days in a row, a local task won't backfill every one of those days — typically only the latest missed run executes, and earlier missed runs are effectively gone. That's also why, even for a local task, it's worth factoring in whether your computer is usually awake at the scheduled time, rather than assuming the catch-up mechanism fully closes the gap.
The root of the difference is where the resources a task needs to touch actually live. A cloud-based scheduled task relies on connectors and files stored in your account — resources Anthropic's servers can reach directly, with no need to go through your computer. But if a task needs to read or write actual files on your local hard drive, the server has no direct path to those files; it can only get to them through your desktop app while it stays connected. That's also why the documentation specifically notes that a remote scheduled task can't be tied to a folder on your computer — it isn't a missing feature, it's a boundary that comes with cloud versus local execution having different reach to begin with.
If you set up a scheduled task using only connectors (Slack, Gmail, Google Drive, and so on) without specifying a working folder, it's almost certainly running in the cloud, and your computer's sleep state won't affect it. The moment you specify a local folder in the setup, or the task requires an app that only runs locally, it gets classified as a local task, and whether your computer is powered on becomes the deciding factor for whether it fires on time. Once it's set up, you can check the Scheduled tab directly for its run history — if past runs line up precisely with the scheduled time even when your computer wasn't on at that moment, that's the signal a cloud task is working as intended.
If your scheduled task is purely about summarizing Slack messages or producing a weekly report from documents in a cloud drive — nothing that touches local files on your machine — design it as a pure cloud task, and you'll get automation that genuinely doesn't care whether your computer is on. That's what most people actually expect the first time they set up a scheduled task. But if a task fundamentally needs to work with local files (organizing a specific folder on your computer, say), the more practical move isn't wondering why it didn't run — it's accepting that this kind of task is inherently local, scheduling it for a time your computer is reliably awake anyway, and designing your workflow around the fact that catch-up only covers the most recent miss, rather than assuming it behaves with the same precision as a cloud task.