Claude Code Desktop: Redesigned for Parallel Agents

1. From sequential to parallel: a different mental model

The original Claude Code experience was fundamentally sequential. You opened a terminal, started a Claude Code session in a directory, gave it a task, watched it work, and got a result. Then you started the next task. The interface reflected this: one active conversation, one codebase, one thing happening at a time. That model works well when you are engaged with what Claude is doing and want to follow along step-by-step.

But a more capable agent creates a different usage pattern. If Claude Code can reliably take a well-defined task and work through it for fifteen minutes without needing your guidance, then watching that one agent execute wastes your time. You could be doing something else — reviewing the last agent’s output, assigning the next task, thinking about the problem you actually need to solve. The value of a capable agent is proportional to how freely you can hand work off to it; if you have to babysit one session at a time, you are artificially throttling the value you get.

The new Claude Code desktop interface is built around this insight. The design premise is that you will have many things in flight simultaneously, and your role is the orchestrator — the person who decides what to work on, assigns tasks to agents, checks in when agents need input or have something to show, and reviews outputs. Not the person executing each step. This shift is subtle but significant: it means you need different tools, a different UI, and a different way of thinking about your workflow.

A useful analogy is the difference between doing a task yourself and delegating it to a team. When you do the task yourself, you think step-by-step. When you delegate to a team, you think about assignments, dependencies, and checkpoints. The new desktop interface gives you the tools to think — and work — like a team lead rather than an individual contributor.

2. The parallel sessions sidebar

The new sessions sidebar gives you a persistent view of all active Claude Code sessions without requiring you to open separate terminal windows or switch between applications. Each session shows the repository it is operating in, the current task description, and its status — actively working, waiting for your input, or complete with results to review.

Switching between sessions preserves full context on both sides. The agent in the background keeps working while you look at another session; the conversation history and task context are intact when you switch back. This is a fundamental difference from managing multiple terminal windows, where you have to actively remember the state of each session and manually navigate through conversation history to understand where each agent is.

The sidebar also solves a discovery problem: when you have three or four tasks running simultaneously, it is easy to forget what you set in motion an hour ago. The sidebar serves as your task list and status board — a quick scan tells you whether everything is progressing, whether any agent needs your input, and whether anything is ready for review.

Crucially, you can start sessions in different repositories. This is what makes truly parallel work possible: one agent refactoring authentication code in the backend API, another implementing a new UI component in the frontend, a third updating documentation to match the API changes. These tasks are often naturally independent — they touch different files, have no shared state, and can be reviewed separately. The sidebar makes it easy to assign all three and let them run while you focus on something that does requires your attention.

3. The notifications center and async monitoring

The notifications center is the mechanism that lets you hand off work and genuinely move on. Rather than periodically switching to each session to check if it has progressed, the notifications center surfaces events that require your attention: a session is waiting for your input on an ambiguous decision, a session has completed a task and has output to review, or a session has encountered an error that it cannot resolve autonomously.

This transforms the parallel session experience from active monitoring to genuine delegation. You assign three tasks, close the sidebar, and work on something else. When a notification arrives, you switch to the relevant session, provide input or review the result, and return to what you were doing. The agent workflow becomes asynchronous — it fits into the gaps of your attention rather than demanding continuous attention.

The design specifically avoids over-notifying. An agent that sends a notification every time it reads a file, runs a command, or makes an edit creates the same cognitive overhead as an agent you are watching. The notifications surface genuinely decision-relevant events: needs input, task complete, task blocked. Everything between is background activity that you do not need to be aware of in real time.

4. Designing effective parallel workflows

Parallel sessions are most valuable when the tasks you assign are genuinely independent — they do not share state, do not modify the same files, and do not need to integrate before you can review them. Designing your work this way is a skill, and it requires thinking about your development work differently.

A good parallel workflow decomposes a larger project into independent subtasks. Implementing a new feature end-to-end is usually not a good parallel task — it requires coordination between backend, frontend, and database changes that have ordering dependencies. But you can often decompose it: one agent writes the API endpoint and tests, another implements the UI mockup, a third audits the existing database schema and proposes the migration. You review all three, then do the integration work yourself or assign a fourth agent to do it with the outputs from the first three as context.

Task granularity matters. Tasks that are too large create sessions that run for a long time before producing reviewable output, and they tend to require more mid-task guidance. Tasks that are too small produce a rapid series of small completions that are more overhead than they are worth. The sweet spot is tasks that take fifteen to forty-five minutes for Claude to complete autonomously and produce a clearly reviewable output — a set of new tests, an implementation of a specific endpoint, a refactored module.

🧠 Check your understanding

4 questions · your answers are saved in this browser only

1. 1. What is the 'orchestrator mental model' for using Claude Code with parallel sessions?

   You write the code yourself and Claude Code reviews it automatically You watch one Claude Code session carefully and only start the next when the first finishes You assign tasks to agents and manage assignments, dependencies, and review — rather than executing each step yourself You let Claude Code run autonomously with no human checkpoints

   The orchestrator model means you act like a team lead: deciding what to work on, assigning tasks to agents, checking in when agents need input, and reviewing outputs — rather than executing each coding step yourself. This is the shift the new desktop UI is designed for.

2. 2. What happens to a background session's context when you switch to view a different session in the sidebar?

   The background session pauses and must be resumed manually The background session's context is saved to disk and reloaded when you switch back The agent keeps working and all conversation history and task context are intact when you switch back Each session is a separate Claude instance with no shared state, so switching loses the background context

   Switching between sessions preserves full context on both sides. The background agent keeps working; the conversation history is intact when you return. This is a core advantage over managing multiple terminal windows.

3. 3. What kind of events does the notifications center surface?

   Every file read, command run, and edit made by any agent Only error events when agents encounter failures they cannot handle Genuinely decision-relevant events: agent waiting for input, task complete for review, task blocked — not routine working steps Notifications from other Claude users in your organization

   The notifications center is designed to avoid over-notifying. It surfaces the events that require your attention — needs input, task complete, task blocked — not routine agent activity like file reads and edits, which would recreate the overhead of watching each session.

4. 4. What is the ideal task granularity for parallel Claude Code sessions?

   Very large tasks (hours of work) so you get maximum efficiency per session Very small tasks (minutes) so you can review frequently and course-correct quickly Medium tasks (15-45 minutes) that Claude can complete autonomously and produce a clearly reviewable output Tasks should always match exactly one file in the codebase

   Tasks that take 15-45 minutes for Claude to complete autonomously hit the right balance: long enough to be worth a parallel session, short enough to produce reviewable output without long waits or lots of mid-task guidance.

Reset quiz

🛠️ Build it yourself

Follow these exact steps to reproduce it yourself

1. Install or update Claude Code desktop — The parallel sessions sidebar and notification center are features of the redesigned desktop app. Update to the latest version from claude.ai/download.
2. Choose a project with separable tasks — Identify a project with at least two or three tasks that are genuinely independent (different files, no shared state, can be reviewed separately). Good candidates: adding a feature endpoint + updating the frontend + writing tests.
3. Write clear task briefs — Before starting any session, write a one-paragraph brief for each task: what needs to be done, what success looks like, any constraints or conventions to follow. Clear briefs reduce mid-task interruptions.
4. Start sessions and assign tasks — Open the desktop app, create a session for each task, and paste the task brief. Verify each agent has understood the task and let it get to work.
5. Switch to something else — Resist the urge to watch agents execute. Do your own work, review earlier output, or plan the next set of tasks. Monitor the notifications center rather than the sessions themselves.
6. Respond to notifications — When a notification arrives (agent needs input, task complete), switch to that session, handle it quickly, and return to what you were doing. Keep interactions short and focused.
7. Review and integrate — When all sessions complete, review each output. Do the integration work yourself or start a new session with all three outputs as context to handle integration.