Inside Claude Code's Rebuilt Desktop: Parallel Agents, Drag-Drop Panes, Side Chat

Anthropic shipped a ground-up rebuild of the Claude Code desktop app on April 14, 2026, the same day Routines went into research preview. The previous desktop was a single-session electron wrapper; the new one is built around the assumption that you are running several Claude Code sessions at once and need somewhere to watch them, switch between them, and ask side questions without losing the thread. It rolls out as an in-app update on Pro, Max, Team, Enterprise, and API plans for macOS, Windows, and Linux.

Key Takeaways

• Multi-session sidebar with status filtering and project grouping
• Drag-and-drop layout -- every pane is movable
• Side chat (Cmd+; or Ctrl+;) reads the main thread and adds nothing back to it
• Three view modes -- Verbose, Normal, Summary -- cycled with Ctrl + O
• SSH on macOS (was Linux-only), now one of four session environments
• HTML/PDF and local-server preview, since expanded into a full Browser pane
• Plugin parity with the CLI, though not feature parity overall
• Since April: routines and scheduled tasks start from Desktop, and auto-archive is opt-in

Update, August 28, 2026. This page has been re-verified against Anthropic's current Claude Code desktop documentation. Two things it originally said are no longer true, and one was wrong on the day it published. Routines can now be created from the desktop app, not only from the web. Session auto-archive on PR merge is an opt-in setting rather than default behavior. And side chat inherits the main thread's context, which the launch announcement said plainly and this page contradicted. The sections below carry the current behavior; the table below lists every correction.

What Changed Since the April 14 Rebuild

Four months of Claude Code desktop releases have moved several of the claims on this page. Each row was checked against code.claude.com documentation on August 28, 2026.

Why Anthropic Rebuilt the Desktop App

The single-session desktop made sense in a world where you started Claude Code, watched it work, and waited for it to finish before the next thing. That world ended sometime in late 2025, when developers stopped treating Claude as a one-at-a-time tool and started running several agents in parallel against different repos. The old desktop did not stop you from doing that, but it did not help either: every parallel session lived in its own terminal window, and orchestration happened in your head.

The rebuild treats the orchestrator role as the default rather than an advanced workflow. The visible shift is the multi-session sidebar: every Claude Code session you have running, and every recent one, in a single panel. The deeper shift is what surrounds it -- a movable pane layout, an integrated terminal, an in-app file editor, a preview pane, and a side-chat affordance for the one-off question that would otherwise break the main agent's context. The aicatchup read on the launch is that this is less an update and more a re-foundation, with parallelism and pane-shaping baked in at the framing rather than retrofitted.

The Multi-Session Sidebar

The sidebar anchors the new app. Every active session shows up there, every recent one too, with filters by status, project, and environment, and grouping by project so a refactor that spans 4 repos collapses into one expandable cluster. Sessions can archive themselves when their PR merges or closes, which keeps the list from accreting forever -- though that is now an opt-in setting, Auto-archive after PR merge or close in Settings -> Claude Code, and it fires only for local sessions that have finished running. Anthropic's launch post described the archiving as automatic; the documented behaviour today is a toggle. Each session also gets its own Git worktree, stored in .claude/worktrees/ by default, so parallel sessions do not step on each other's changes until you commit.

This is also where a Routine run lands. At launch Routines were configured on the web at claude.ai/code/routines; today the Code tab carries its own Routines page in the sidebar, and New routine lets you pick Cloud for a routine that runs on Anthropic's infrastructure or Local for a Desktop scheduled task that runs on your machine. Web, Desktop, and CLI all write to the same account, so a routine created in one surface appears in the others. The practical result is unchanged and now stronger: the desktop is the single place to create and review work, your live local sessions alongside your scheduled or webhook-triggered runs.

The sidebar also surfaces a usage button that shows context window and session usage at a glance. For long parallel runs that is the difference between noticing a session is about to hit context pressure and finding out by way of a degraded reply. The same observation applies in slower-burn contexts; the practices guide on Claude Code context management goes deeper on how to budget context across long sessions and parallel agents.

Drag-Drop Panes and the New Layout

Every component in the app is a movable pane. Anthropic's docs now enumerate them: chat, diff, browser, terminal, file, plan, tasks, and subagent, plus the iOS Simulator on macOS. Drag a pane by its header to move it, drag an edge to resize it, Cmd/Ctrl + \ closes the focused pane, and the Views menu in the session toolbar opens the rest. There is no fixed split-pane layout you have to talk yourself out of. The pane layout, terminal, file editor, and view modes all require Claude Desktop v1.2581.0 or later.

The integrated terminal runs in-app, which means tests and builds happen in the same window as the chat that triggered them, in the session's working directory and with Claude's environment. It is available in local sessions only -- `Ctrl + `` toggles it. The in-app file editor covers spot edits without round-tripping to an external IDE, which historically meant alt-tabbing to VS Code or Cursor for any change above a one-liner; it works in local and SSH sessions, and in a cloud session you ask Claude to make the change instead. The rebuilt diff viewer is optimized for the kind of large changesets parallel agents produce, with the browser pane sitting next to it for visual checks. Right-clicking a file path gives you Open in for VS Code, Cursor, or Zed when the edit is bigger than a spot fix.

The preview surface has grown the most since April. It is now the Browser pane, and it is a tabbed browser rather than a viewer: it renders HTML, PDF, images, and video from your project, it hosts local app servers so a dev server on localhost:3000 can sit next to the chat editing it, and it opens external sites such as docs and issue trackers alongside them. Claude verifies its own changes there by taking screenshots, inspecting the DOM, clicking, and filling forms. It runs on a clean browser profile with none of your logins, which is the deliberate split from the Claude in Chrome extension. Administrators can restrict it: browserExternalPageTools turns off Claude's tools on external pages, and disableBrowserExternalNavigation blocks external sites outright while leaving localhost previews working.

Plugin support reaches parity with the CLI. The same plugins, centrally managed or local, load in the desktop -- so a team that has standardized on a shared plugin set in their Claude Code CLI gets the same set in the desktop without re-configuring, through a plugin manager UI rather than the CLI's /plugin command. Parity on plugins is not parity everywhere, and Anthropic's docs keep an explicit list of what Desktop lacks: no autocomplete-style inline code suggestions, no --print or Agent SDK scripting, no agent teams, and no third-party model providers without a gateway. A full keyboard shortcut palette is a Cmd/Ctrl + / away when you want to learn the bindings rather than hunt for them.

Side Chat: Branch a Question Without Breaking Your Flow

The single feature most likely to change daily habits is side chat, bound to Cmd + ; on macOS and Ctrl + ; on Windows, or typed as /btw in the prompt box. The flow is asymmetric, and that asymmetry is the point: the side chat can read everything in the main thread up to that point, but nothing you ask there is added back to the main conversation. So you can interrogate the architect about a design choice, with the full context of the run already loaded, while the implementation agent keeps working without learning anything that would change how it interprets its task. Two limits worth knowing: side chats work in local, SSH, and WSL sessions but not cloud ones, and the desktop app does not save them to disk, so closing the app loses the thread.

This sounds minor and is not. The reflex with a single-thread chat is to either interrupt -- wrecking the context the agent has built up -- or to not ask, and lose the thread of your own thinking. Side chat splits the difference: ask now, keep the main run clean. For long-running agentic tasks where you want to clarify or rubber-duck without rewinding, the affordance maps well to how parallel-agent work actually feels.

The same logic underwrites the three view modes, which sit a step lower in the same problem space: how much do you let into your attention while the agents run.

The Three View Modes -- When to Use Each

The new desktop ships Verbose, Normal, and Summary view modes, switched from the Transcript view dropdown next to the send button or cycled with Ctrl + O on either platform. The shift is at the level of how much tool-call activity the chat surface shows you.

Verbose is the audit view. Use it when you are debugging why Claude took a particular action, or when you want to learn how a model approaches a class of task and you do not yet trust the high-level summary.

Normal is the default for active work. You see the work without drowning in it: tool calls collapsed to summaries, full text responses intact.

Summary is the review view, and Anthropic's own recommendation is to reach for it when you are running several sessions and want to scan results quickly. The pattern that follows is to read a finished run in Summary, identify the spots that need scrutiny, and cycle back to Verbose to audit a specific tool call.

The mode controls how much tool-call activity you see, so switching mid-session is a view change rather than a re-run.

SSH and Remote Dev Workflows

SSH support is now available on macOS. It was Linux-only on the old desktop, which forced Mac developers either onto the CLI or into a separate terminal app whenever the work needed to happen against a remote box. The new desktop closes that gap: open an SSH session from your Mac, with the same sidebar, panes, and view modes as a local session.

SSH has since become one of four environments you pick before a session starts, alongside Local, Cloud, and WSL on Windows. Add a connection from the environment dropdown with + Add SSH connection: host as user@hostname or a ~/.ssh/config entry, port defaulting to 22, and an optional identity file. The remote machine must run Linux or macOS, and Desktop installs Claude Code there automatically the first time you connect. Once connected, SSH sessions carry permission modes, connectors, plugins, and MCP servers.

Two of those controls are not yours if you are on a managed device, which is the question to ask before planning a workflow around any of this. Administrators can push connections to the whole team with sshConfigs in a managed settings file, where they appear in every user's dropdown and cannot be edited. They can restrict which hosts you reach with sshHostAllowlist, and setting that to an empty array disables SSH sessions entirely. A separate disableDesktopLocalSessions setting greys out Local, in which case new sessions default to the first configured SSH connection.

The practical use case is remote-pair against a dev box that mirrors production. Run agents against the same dependency versions, the same data, the same network topology your service hits in prod. For teams whose local laptops cannot host the full stack -- large monorepos, GPU workloads, regulated data sets -- this turns the desktop into a front end for remote dev environments rather than a strictly local tool.

The keyboard-driven flow holds across remote sessions: side chat, view modes, the shortcut palette at Cmd/Ctrl + / all work the same against the SSH target as against a local repo. The exceptions are narrow and worth knowing: the integrated terminal is local-only, and Continue in -> Claude Code on the Web is not offered for SSH sessions.

How the Desktop Integrates With Routines

The desktop and Routines are deliberately complementary surfaces, not competing ones. Cloud routines run on Anthropic's infrastructure, on a schedule, an HTTP trigger, or a GitHub event, and do not need your laptop to be open. What has changed since April is where you create them: the Code tab now has its own Routines page in the sidebar, and New routine asks whether you want Cloud or Local. Choosing Local creates a Desktop scheduled task instead, which runs on your machine with access to your files, fires only while the app is open and the computer is awake, and accepts intervals down to one minute against the cloud routine's one-hour floor. If Routines is missing from your sidebar, that is the eligibility answer: routines need a Pro, Max, Team, or Enterprise plan with Claude Code on the web enabled, and on Team and Enterprise a workspace Owner can switch the feature off for everyone.

What they do need, eventually, is a place to be reviewed. That place is the desktop sidebar. Every Routine run -- the 3am stale-PR sweep, the docs-sync-on-push, the issue-triage on issues.opened -- lands in the sidebar as a session, with the same filters, the same view modes, the same diff viewer as a session you started yourself. You can scroll through what the Routine did, audit a specific tool call in Verbose, see the PR it opened, all in the same window where your live work is happening.

The wider desktop story is the orchestration story: parallel local sessions in panes, scheduled and webhook-triggered runs streaming into the sidebar, SSH against a remote box for environments your laptop cannot host, side chat for the question you would otherwise have lost. Anthropic's own framing on launch day was that "the shape of agentic work has changed", with the developer "in the orchestrator seat" -- a chat-and-pane window as the primary interface, with the editor and terminal as panes inside it rather than separate apps. Whether that holds for your workflow likely depends on how editor-heavy your day is: the docs are candid that Desktop offers no inline code suggestions and no scripted headless mode. The Cursor vs Claude Code comparison walks through where each tool still wins, and parallel-agent-in-one-window is also the bet behind the Warp agentic development environment, which approached the same problem from the terminal side.

The April 14 release is the bet that orchestration is the default mode of working with Claude Code now, and the desktop's job is to make orchestration cheap. Four months of releases have gone the same direction: auto-continue after a usage limit resets, an iOS Simulator pane, sessions you start from your phone, and a Linux beta. If that maps to how you already work, the rebuild lands clean. If it does not, the sidebar and view modes are still a real upgrade over the single-session app they replaced.

Sources

• Redesigning Claude Code on desktop for parallel agents, Anthropic blog, April 14, 2026: https://claude.com/blog/claude-code-desktop-redesign
• Desktop application reference, Claude Code docs: https://code.claude.com/docs/en/desktop
• Schedule recurring tasks in Claude Code Desktop: https://code.claude.com/docs/en/desktop-scheduled-tasks
• Automate work with routines: https://code.claude.com/docs/en/routines
• Get started with the desktop app: https://code.claude.com/docs/en/desktop-quickstart