Sub-Agent Timeout: Why Your Parallel Agents Never Finish

You asked Cowork to do something ambitious, watched it spin up a little fleet of helper agents, and then… nothing. The spinner keeps going. The agents never come back. You are not sure whether to wait, panic, or close the laptop and pretend it never happened.

You are not alone. Sub-agent timeouts are one of the most common rough edges in Claude Cowork right now, and the fixes are mostly straightforward once you understand what is actually happening.

What Sub-Agents Are (in Plain Terms)

When you give Cowork a big or multi-part job, it does not always try to do everything itself in a single linear pass. Instead, it can split the work into parallel helpers called sub-agents. Think of it as the main agent spinning up several colleagues, handing each one a chunk of work, and waiting for them all to report back before assembling the final answer.

This is genuinely useful for tasks like “summarize all twelve of these documents” or “run these four searches and compare the results.” Each sub-agent works independently, and in theory they all finish and report back to the coordinator.

In practice, one of them gets stuck, and the coordinator waits forever because it does not know how to proceed without that missing piece.

Why Sub-Agents Time Out

There are five main causes, and knowing which one you are hitting points you to the right fix.

1. Too many sub-agents at once. Cowork has a limit on concurrent sub-agents, and it is lower than you might expect. Sending a prompt that implicitly requires six parallel agents (for example, “research all of these topics simultaneously”) can saturate the available slots. Agents queue up, the queue stalls, and nothing finishes.

2. A sub-agent waiting on a blocked resource. If one sub-agent needs to read a file that another agent currently has locked, or is waiting on a tool call that never returns (a slow MCP server, a network request to a downed API), it will simply wait. And keep waiting. The coordinator has no mechanism to time out a sub-agent and move on without it.

3. The task per agent is too large. Sub-agents inherit the same context window constraints as the main conversation. If you hand one sub-agent a task that requires processing a very large file or a very long chain of reasoning, it can silently exceed limits or get stuck in a reasoning loop that never resolves.

4. Network stalls. Cowork’s sandbox needs a working internet connection to communicate with the Claude API. A brief dropout mid-task can leave a sub-agent mid-sentence with no way to complete its turn. On Windows in particular, VPN software and corporate proxies can introduce intermittent stalls that are just long enough to break a long-running agent without dropping your connection entirely.

5. An infinite or very long reasoning loop. Occasionally an agent will try a fix, check whether it worked, find it did not, try again, check again, and repeat this cycle until it either succeeds or you close the window. This is not strictly a bug, but it is deeply unhelpful when you are waiting for a result.

Step-by-Step Fixes

Try these in order. Most people are unblocked by step 2 or 3.

1. Wait two more minutes. Seriously. Some tasks that look frozen are just slow. If there has been any visible progress in the last few minutes, give it a bit more time before intervening.

2. Restart the session. Close the current conversation and open a new one. Check your files first so you know what completed. Then re-send your request. This clears any stuck state in the coordinator and the sub-agents.

3. Break the task into smaller steps. Instead of “do all of X,” send “do step one of X” and wait for it to finish, then send step two. This removes the need for parallel sub-agents entirely and is the single most reliable way to avoid this class of problem.

4. Ask explicitly for sequential execution. In your prompt, add something like “please do these one at a time, not in parallel.” Cowork will generally honor this. It is slower but much more reliable for complex multi-part work.

5. Simplify the prompt. If your prompt implies a very large scope (many files, many searches, many tool calls), pare it down. Complexity correlates directly with timeout risk.

6. Check your network connection and VPN. If you are on a corporate VPN or behind a proxy, try disconnecting temporarily and retrying. See the Failed to Start Workspace guide for more detail on network-related Cowork failures.

7. Restart the Claude desktop app. If session restarts do not help, quit the app entirely and relaunch it. On macOS, use Cmd+Q. On Windows, right-click the system tray icon and choose Quit.

8. Update the app. Check for updates in the app menu. Anthropic ships fixes for stability issues regularly, and the current build may have a known patch for whatever you are hitting. Release notes are published at https://www.anthropic.com.

9. Restart your machine. Dull advice, but effective when the app itself is in a bad state. On Windows especially, network stack weirdness can persist across app restarts and only clear on a full reboot.

When None of This Works

If you have tried all of the above and your agents still hang reliably on a specific type of task, the most productive next step is to check whether there is an open issue on the Anthropic GitHub for your exact symptom. Other users hitting the same wall often leave useful workarounds in the comments.

You can also reach the Cowork support team via https://support.claude.com. Include the type of task, approximately how many sub-agents you think were involved, and what the last visible action was before the hang. That context speeds up diagnosis significantly.

What to Expect Going Forward

Cowork is a research preview. Sub-agent orchestration is one of the newest and most complex parts of the system, and timeout handling is an area Anthropic has flagged for improvement. The honest expectation right now is that parallel sub-agents work well on small, well-defined parallel tasks and get unreliable on anything open-ended or large in scope. Sequential prompting is not a workaround; for anything important, it is currently the right approach.

That said, the core capability is real and genuinely useful. Breaking tasks into smaller chunks is not just a stability fix. It also tends to produce better results because each agent has a clearer, more focused job.