Domain 1 · Task Statement 1.2

How Cowork Executes Tasks

TL;DR

Master the five-stage execution pipeline that turns a single instruction into coordinated, parallel work across your file system.

What You Need to Know

Every task you hand to Cowork passes through a five-stage execution pipeline. Understanding this pipeline is the difference between treating Cowork as a chatbot that occasionally edits files and wielding it as a genuine agentic system that coordinates complex, multi-step work autonomously. The pipeline runs identically whether you're renaming three files or producing a quarterly board pack from fifty data sources. Get to know it well — it governs everything Cowork does.

Stage 1: Request Analysis

The moment you submit a task, Cowork analyses three things simultaneously: what you're asking for, what resources exist in the scoped directory, and what constraints or ambiguities sit in your instruction. Ask it to "create a summary report from the CSV files in this folder" and it inventories the folder contents, checks file sizes, identifies column headers, and flags anything unclear — all before proposing a single action.

This stage is invisible. Its quality depends entirely on the clarity of your prompt. Vague instructions ("tidy up these files") force Cowork to guess. Precise instructions ("rename all files to YYYY-MM-DD_ClientName_Project format") let it skip clarification and move straight to planning.

[i]

Why the Analysis Stage Matters

Request analysis is where Cowork decides whether a task is straightforward enough for a single agent or complex enough to warrant decomposition into parallel sub-agents. A well-scoped prompt with a clear end-state lets the system make this call faster and more accurately. A vague prompt may cause it to under-decompose — processing files sequentially when parallelism would cut execution time by 80%.

Stage 2: Plan Creation

Before touching a single file, Cowork produces a visible execution plan — a structured list of every read, write, move, create, and delete operation it intends to perform. A contractor showing you blueprints before knocking down walls. The plan appears in your task interface for explicit review.

Don't mistake this for a courtesy. It is the primary safety mechanism in the entire system. Which files will be modified? Which new files created? Which folders restructured? And — critically — which files deleted? The plan tells you all of it. You have full authority to approve, reject, or modify before execution begins.

[!]

The Plan Is Your Safety Net

The execution plan is the single most important checkpoint in any Cowork task. Skipping it is the leading cause of accidental file loss reported by users. For tasks involving deletions, bulk renames, or cross-folder moves, reading the plan takes thirty seconds and can prevent irreversible damage — particularly when parallel sub-agents will multiply any misinterpretation across dozens of files simultaneously.

Stage 3: Subtask Decomposition

Complex goals get broken into smaller, independent units of work. Ask Cowork to "create a quarterly report from 50 CSV files" and it might decompose that into: inventory all files and validate column structure, categorise by region or business unit, extract key metrics from each group, build summary tables and pivot calculations, generate charts, and assemble the final document.

None of this is random. Cowork identifies dependency chains — subtasks that must complete before others can begin — and independent operations that can safely run in parallel. File categorisation? Independent per file. Chart generation? Depends on completed summary tables. The system sequences all of this automatically.

Stage 4: Parallel Execution via Sub-Agents

Here is where Cowork's agentic architecture diverges most sharply from standard chat. For independent subtasks, Cowork spawns sub-agents — temporary, parallel instances of Claude that each handle a piece of the work simultaneously. Fifty CSV files to categorise? Five sub-agents processing ten files each, rather than grinding through all fifty in sequence.

These sub-agents operate within the same sandboxed VM as the parent task. They share access to the scoped directory but coordinate through the parent to avoid file conflicts. When every sub-agent finishes, the parent aggregates their outputs and moves on to the dependent subtasks.

[~]

When Parallelism Activates

Sub-agent parallelism doesn't trigger for every task. Cowork activates it when decomposition reveals a batch of structurally similar, independent operations — processing multiple files, summarising multiple documents, or applying the same transformation across a dataset. A single-file task or a strictly sequential workflow executes in a single thread. The more independent work units your task contains, the more parallelism you get.

Stage 5: Output Delivery

When all subtasks complete, Cowork writes the finished outputs directly to your file system within the scoped directory. No download step, no clipboard, no manual save. Asked for an Excel file? It appears in your folder. Asked for a restructured directory? The folder already reflects the changes.

You also get a summary of what happened — which files were created, moved, renamed, or deleted — giving you an audit trail of the entire operation. For complex tasks involving sub-agents, this summary rolls up the work of every parallel worker into a single report.

[!]

Execution Requires a Live Session

Everything in this pipeline runs locally in a sandboxed VM on your machine. Close the Claude Desktop app, put your computer to sleep, or lose power, and the task terminates immediately. There's no cloud fallback and no resume capability. For long-running tasks, keep the app open and your machine awake. Standalone sessions don't carry memory between tasks either — that requires Projects.

The Pipeline in Practice

Picture this: your finance team drops 80 expense reports as PDFs into a shared folder and asks for a consolidated summary by department. You submit one instruction to Cowork. Stage 1 inventories the 80 PDFs and identifies their structure. Stage 2 produces a plan showing how it will categorise, extract, and consolidate. Stage 3 decomposes into per-PDF extraction (independent) and consolidation (dependent). Stage 4 spawns sub-agents to extract data from multiple PDFs concurrently. Stage 5 delivers a single summary spreadsheet to your folder.

From one sentence to a finished deliverable — without you touching a file. Your role: write a precise instruction, review the plan, approve execution.

Common Mistakes

Common Mistake

Clicking 'Allow' on the execution plan without reading it. Users treat plan review as a formality and approve immediately, especially after a few successful tasks build false confidence.

Instead: Read every plan, every time. Pay particular attention to delete operations, bulk renames, and cross-folder moves. The plan is your only checkpoint before sub-agents multiply actions across dozens of files. A misinterpreted instruction in the plan becomes an irreversible mistake at execution.

Common Mistake

Prescribing every individual step instead of describing the desired outcome. Users write instructions like 'First open file A, then look for column B, then copy cell C3 to D3, then save, then open file E...' — dictating to Cowork as though it were a macro recorder.

Instead: Describe the end-state and let Cowork determine the execution path. Say 'Consolidate all quarterly CSV files into a single Excel workbook with a summary pivot table by region, and archive the originals into a subfolder called Processed.' Cowork's decomposition engine will find a faster, more reliable path than your step-by-step script.

Common Mistake

Closing the laptop lid or quitting the Desktop app mid-task, assuming Cowork will continue processing in the cloud.

Instead: Keep the Claude Desktop app open and your machine awake for the full duration. Cowork runs locally in a sandboxed VM — there's no background process or cloud continuation. For tasks that take more than a few minutes, minimise the app rather than closing it.

Delegating a file organisation task to Cowork

Before

Go into my /Clients folder and fix the naming of the files so they look better.

After

In the /Clients folder, rename all files to the format 'YYYY-MM-DD_ClientName_Project'. Move anything older than 2024 to an /Archive subfolder. Produce an Excel spreadsheet listing the original name, new name, and status for every file. Show me the plan before proceeding.

Processing a batch of data files

Before

Process these files for me.

After

For each CSV file in this folder, extract the 'Revenue' and 'Region' columns, calculate the quarterly total per region, and combine everything into a single summary Excel file with a pivot table and bar chart. Save it as 'Q1-Regional-Summary.xlsx'.

Hands-On Activity

Hands-On Activity

Observe the Execution Pipeline in Action

15 min

Trigger all five pipeline stages with a single task and identify each stage as it happens. This makes the abstract pipeline concrete — you'll directly observe request analysis, plan creation, decomposition, parallel execution, and output delivery.

What you will learn

  • Identify each of the five execution pipeline stages in a live Cowork session
  • Read and evaluate an execution plan before approving it
  • Observe sub-agent parallelism during batch file processing
  • Verify output delivery by inspecting the file system after completion
  1. 01

    Create a folder called 'Pipeline-Test' on your desktop. Add 10-15 varied files: text documents, images, old spreadsheets, PDFs — anything you have. The more variety, the richer the decomposition.

    Why: A mix of file types forces Cowork to decompose the task into different processing paths (categorisation, content analysis, metadata extraction), making each pipeline stage more visible.

    Expected: A folder with 10-15 diverse files ready for processing.

  2. 02

    Open Cowork mode, select the 'Pipeline-Test' folder, and submit this task: 'Organise these files by type into subfolders. For every text-based file, create a one-sentence summary of its contents. When done, create a Manifest.md listing every action you took, including which files were processed by which sub-agent.'

    Why: This task spans multiple stages (categorisation, content analysis, file creation) and explicitly requests a manifest — giving you visibility into the decomposition and parallel execution.

    Expected: Claude generates a detailed execution plan showing the stages of work it intends to perform.

  3. 03

    Stop and read the execution plan carefully. Identify which operations are listed as independent (can run in parallel) and which depend on earlier steps completing first. Confirm that no files are being deleted.

    Why: Here you see Stages 1-3 in action: request analysis (already done), plan creation (visible now), and subtask decomposition (shown in the plan structure). Building this review habit is what separates expert users from casual ones.

    Expected: The plan shows distinct phases: file analysis, folder creation, file moves, content summarisation, and manifest generation — with some marked for parallel processing.

  4. 04

    Approve the plan and watch the progress indicators. Look for multiple sub-agent progress bars appearing simultaneously — these show parallel processing of independent subtasks.

    Why: With 10-15 files, Cowork should trigger sub-agents to handle categorisation and summarisation concurrently rather than sequentially. This is Stage 4 in action.

    Expected: Multiple progress bars moving simultaneously as sub-agents handle different files. The total execution time should be noticeably shorter than if each file were processed one at a time.

  5. 05

    Once complete, open the Pipeline-Test folder on your desktop. Verify the subfolders were created, files were moved correctly, summaries exist for text-based files, and Manifest.md lists every action taken.

    Why: This is Stage 5 — output delivery. Everything was written directly to your file system. The manifest gives you an audit trail of the entire operation, including which sub-agents handled which files.

    Expected: Organised subfolders by file type, summary files for text-based content, and a Manifest.md documenting every action — all created without you touching a single file.

Practice Question

Practice Question

You have a folder containing 100 CSV files. You ask Cowork to 'Categorise these by region, create a summary for each region, and compile a final executive report.' What is the most likely way Cowork will execute this task?

Sources