Dispatch Tasks to Claude Cowork from Anywhere

1. The Shift from Synchronous to Asynchronous AI

Every AI assistant that existed before Cowork Dispatch was built around a synchronous model of interaction. You open the tool, type a prompt, and wait. The model generates a response, you read it, you decide what to ask next. The entire workflow is built around you being present and attentive while the AI works. This is fine for short tasks — summarizing a paragraph, answering a question, generating a first draft — but it breaks down entirely for longer tasks, because it means the AI is only as fast as you are willing to sit and watch it work.

Cowork Dispatch is built on a different premise: that the most valuable thing an AI assistant can do for a busy person is to work while that person is doing something else. The shift from synchronous to asynchronous AI is not a minor UX improvement. It is a fundamental change in the relationship between the user and the tool. In synchronous mode, you are always in the loop; the AI is a very fast responder to your inputs. In asynchronous mode, you are a manager assigning work to an agent that executes independently; you return to check results rather than watching them happen.

This shift has profound implications for what kinds of tasks are worth delegating to AI. In synchronous mode, it is only efficient to delegate tasks that the AI can complete faster than you could do them yourself in real time. In asynchronous mode, the efficiency calculation changes entirely: you can delegate any task that takes longer than a minute, because the time cost to you is now just the time to write the task description plus the time to review the result — not the full duration of the work itself.

2. How Dispatch Works: One Continuous Thread

The technical foundation of Dispatch is a persistent conversation thread. Unlike a typical AI chat session that starts fresh each time you open the application, Dispatch maintains a single continuous conversation for each project or workflow you set up. When you assign a task from your phone and come back to your desktop two hours later, Cowork remembers not just what you asked it to do, but the full context of everything that has come before in that thread: the documents it has read, the edits it has made, the clarifications you provided, and the results it has already delivered.

This continuity matters more than it might initially seem. Consider a multi-step workflow: you ask Cowork to pull the monthly sales data from a browser-based dashboard and paste it into your tracking spreadsheet, then calculate the variance from last month, then draft a summary paragraph for the leadership email. If Cowork had to start from scratch each time you opened the app, it would need to re-read all the relevant files and re-establish all the context on each step. With a persistent thread, it carries that understanding forward. The spreadsheet it updated in step two is already in its context when it writes the summary in step three.

Dispatch threads are organized by project rather than by session. You might have one thread for your weekly reporting workflow, another for a long-running document drafting project, and a third for a research task that you return to intermittently. Each thread is independent, with its own context and history. This means you can have Cowork working on one thread on your desktop while you check in on the status of another thread from your phone — the two workstreams do not interfere with each other.

3. The Cross-Device Workflow in Practice

The most common Dispatch scenario is the commute assignment: you are on a train or in a car on the way to the office, you pull out your phone, and you describe a task for Cowork to complete on your desktop before you arrive. By the time you sit down at your computer, the draft is written, the spreadsheet is updated, or the research is compiled. You spend your commute time productively assigning work rather than waiting until you are at a desk to start the delegation.

To use Dispatch from your phone, you open the Cowork mobile companion app and navigate to the thread for the relevant project. You type — or dictate — the task description in the same natural language you would use on desktop. The app sends the task to the Cowork agent running on your desktop. If your desktop is asleep, Cowork queues the task and begins executing as soon as the machine wakes up or the screensaver clears. If your desktop is already on and Cowork is running, execution begins immediately.

The mobile app is intentionally lightweight: it is designed for assigning tasks and reviewing results, not for extended back-and-forth. If a task requires significant context-setting or you need to reference files that are only accessible from your desktop, those are better handled from the desktop interface. Think of the mobile app as the dispatch terminal and the desktop as the execution environment — they are complementary rather than interchangeable.

4. Conversation Continuity and Why It Matters

The persistence of the Dispatch thread is what makes it possible to work on genuinely complex projects over time rather than just running isolated tasks. When you come back to a thread after a day away, Cowork knows what has already been done in that thread, what files it has read, and what decisions were made along the way. You do not need to re-explain the project from scratch. You just describe the next thing you need done.

This has a compounding effect on productivity. The first time you ask Cowork to do something in a new project, there is some overhead in getting it oriented: which files are relevant, what the naming conventions are, what the output format should look like. But on the second, third, and tenth task in the same thread, that overhead is gone. Cowork already carries that context. Asking it to update this week’s version of a weekly report it has been maintaining for six weeks is dramatically faster than asking a fresh session to do the same thing.

Context continuity also means Cowork can notice patterns and inconsistencies across sessions. If you ask it to pull data from a source it has pulled from before and the format has changed, it will flag that. If a file it expects to find in a certain location has been moved, it will tell you rather than silently failing. This kind of cross-session awareness is only possible because the thread is persistent — a stateless session would have no way of knowing that something had changed since last time.

5. Choosing the Right Tasks for Async Dispatch

Not every task is well-suited to asynchronous execution. Understanding which tasks are good Dispatch candidates — and which are not — will save you frustration and produce better results from the tasks you do delegate.

The best Dispatch candidates share three characteristics. First, they have clear completion criteria: there is a definite state of “done” that Cowork can reach and recognize, rather than a task that requires ongoing judgment about when to stop. “Compile a list of the top 10 competitors mentioned in these three reports and summarize their key differentiators” is a task with a clear endpoint. “Improve our strategic positioning” is not. Second, good Dispatch tasks are resilient to interruption: if Cowork finishes the task and you do not check it for two hours, the result is still valid and usable. Time-sensitive tasks that need your review within minutes are better handled synchronously. Third, they do not require your judgment mid-flight: if completing the task properly requires a decision that only you can make, Cowork will have to pause and ask, which defeats the purpose of async delegation.

The best task categories for Dispatch are: research and summarization (compile, compare, extract), document drafting from an existing brief or template, data pulls and spreadsheet updates where the logic is clear, routine formatting and reformatting tasks, and email drafts where you have given Cowork clear guidance on tone and key points. Tasks to keep synchronous include anything involving external communications that go out immediately, financial transactions, and decisions where the range of possible outcomes is wide and the wrong choice is costly.

6. Notifications, Monitoring, and When Claude Gets Stuck

When Cowork completes a dispatched task, it sends you a notification through the Cowork mobile companion app. The notification includes a brief summary of what was done and a link to open the completed thread so you can review the results. If the task involved file edits, the notification will tell you which files were modified. On desktop, the notification appears in the system notification center as well, so you will see it when you return to your machine.

Sometimes Cowork will encounter a situation where it cannot proceed without guidance from you. The most common cases are: the file it expected to find has been moved or renamed, the task description was ambiguous enough that two reasonable interpretations would lead to different results, or an action it needs to take requires a permission it has not been granted. In these cases, Cowork pauses rather than guessing, and sends you a clarifying question through the same notification channel. You can answer from your phone and it will resume execution immediately.

The ability to answer mid-task questions from your phone is one of the features that makes Dispatch genuinely useful for complex work rather than just simple tasks. If you had to be at your desktop to answer every clarifying question, the async model would break down the moment a task encountered any ambiguity. The mobile response capability means Cowork can handle more complex, multi-step work because you can unblock it quickly even when you are away.

7. Permissions in Async Mode

The permission model is especially important in asynchronous mode, precisely because you are not present to approve individual actions as they happen. Before dispatching any task, Cowork will verify that the actions required to complete it fall within your pre-configured trusted operations list. If the task requires an action that is not pre-authorized, Cowork will either ask you upfront (before you walk away) or pause mid-task and notify you, depending on when it discovers the gap.

This is by design. The alternative — giving Cowork unlimited autonomy to take any action necessary to complete a task while you are unavailable — would be dangerous. You cannot review a sequence of actions you did not anticipate, and the blast radius of an unexpected mistake is larger when you are not present to catch it early. The permission rules you set before delegating are the guardrails that keep Dispatch safe. They are not a limitation on what Cowork can do; they are the mechanism that makes it possible to trust Cowork with real work when you are not watching.

Build your permission rules incrementally, based on the tasks you actually dispatch regularly. If you routinely dispatch tasks that involve reading files and writing draft documents, authorize those operations. If you never dispatch tasks that involve sending emails, do not authorize email sending — leave it requiring your approval. The goal is a permission set that covers your common Dispatch workflows completely, so Cowork can run through them without interruption, while still requiring your sign-off on anything unusual.

🧠 Check your understanding

5 questions · your answers are saved in this browser only

1. 1. What is the fundamental shift that Dispatch introduces to AI assistant interaction?

   From text-based to voice-based interaction From synchronous (you wait while it works) to asynchronous (you assign and walk away) task execution From cloud processing to local processing on your device From individual use to team collaboration features

   Dispatch shifts the interaction model from synchronous (you stay present while the AI responds) to asynchronous (you assign the task, leave, and return to find it done) — fundamentally changing the efficiency calculation for what tasks are worth delegating.

2. 2. How does Dispatch's persistent thread improve performance on repeated tasks in the same project?

   It caches the output of previous tasks so they do not need to be re-run It gives Cowork higher system priority after the first task in a thread It retains context — files read, decisions made, output formats established — so each subsequent task in the same project requires less setup It pre-downloads all files in the project folder for faster access

   A persistent thread means Cowork carries forward everything it learned in previous sessions: which files are relevant, what formats to use, what decisions were made. This eliminates the re-orientation overhead that would otherwise be required on every new session.

3. 3. Which of these tasks is the BEST candidate for async Dispatch?

   Deciding which vendor proposal to accept based on multiple competing factors Sending an urgent reply to a client email that needs a response within the next 10 minutes Compiling a list of competitors mentioned across three research reports and summarizing their key differences Adjusting the tone of a message mid-conversation with a colleague in a live chat

   The research compilation has a clear completion criterion, does not require your judgment mid-flight, and is not time-sensitive in a way that prevents async handling. The other options require real-time judgment or immediate human review.

4. 4. What does Cowork do when it encounters an action that is not covered by your pre-set permission rules during an async task?

   It proceeds with the action anyway since you already initiated the task It cancels the entire task and discards all work completed so far It pauses, sends you a notification with a clarifying question, and waits for your response before continuing It sends the task to your organization's IT administrator for approval

   Cowork pauses rather than proceeding without authorization, sends you a notification through the mobile app, and waits for your response. This keeps you in control even during async execution.

5. 5. Why does Cowork require pre-set permission rules even when you are the one initiating the async task?

   Legal regulations require it for all AI systems Because you cannot review individual actions mid-task when you are away, permission rules serve as the guardrails that keep unexpected mistakes from having large consequences To prevent other users on your network from seeing your task history Because async mode uses a less capable version of the Claude model that needs more guidance

   When you are not present to review each action in real time, pre-set permissions are the mechanism that limits the blast radius of any unexpected decision Cowork might make. They are not restrictions on capability — they are what makes async delegation safe.

Reset quiz

🛠️ Build it yourself

Follow these exact steps to reproduce it yourself

• Install the Cowork mobile companion app on your phone and sign in with the same account as your desktop Cowork installation
• Open the Cowork desktop app and create a new Dispatch thread for a recurring workflow — your weekly report, a long-running research project, or a document you are drafting over multiple sessions
• Before your first async dispatch, configure the permission rules for the actions that workflow requires: read access to the relevant folder, write access to the output file, and draft (not send) access if email is involved
• Write a task description from your desktop that is self-contained: name the files, describe the goal, and specify the output format — then test it in a synchronous session while you are at your desk to see how Cowork interprets it
• Once you trust the task description, dispatch the same task from your phone while your desktop is running and step away — use the time to do something else while Cowork works
• When you receive the completion notification, open the thread and review the result; note anything that was surprising or off, and refine your task template for next time
• After two or three successful runs, add the actions Cowork used to your trusted operations list so future dispatches of the same workflow run without interruption