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/Ctrl+;) for asides without polluting main thread context
• Three view modes: Verbose, Normal, Summary
• SSH on macOS (was Linux-only) for remote dev workflows
• HTML/PDF and local-server preview pane
• Plugin parity with the CLI

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 auto-archive when their PR merges or closes, which keeps the list from accreting forever.

This is also where a Routine run lands. Routines are configured on the web at claude.ai/code/routines, but every fire shows up in the desktop sidebar as a session you can scroll through. The practical result is that the desktop becomes the single place to review work -- your live local sessions and your scheduled or webhook-triggered Routine runs -- without bouncing between surfaces.

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. The terminal, the file editor, the diff viewer, the preview, the chat itself -- all draggable, all repositionable. There is no fixed split-pane layout you have to talk yourself out of.

The integrated terminal runs in-app, which means tests and builds happen in the same window as the chat that triggered them. 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. The rebuilt diff viewer is optimized for the kind of large changesets parallel agents produce -- cleaner navigation through long diffs, with the preview pane sitting next to it for visual checks.

The preview pane itself is broader than you might expect. It renders HTML and PDF directly, but it also supports local app servers, so a Next.js dev server on localhost:3000 can sit in a pane next to the chat that is editing it. Iterate the agent, see the rendered change, no alt-tab. Combined with the integrated terminal, the desktop now covers most of the loop a UI tweak requires inside one window.

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. 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/Ctrl + ;. You hit the shortcut mid-run and a fresh chat opens off to the side. Whatever you ask there does not enter the main thread's context, which means you can interrogate the architect about a design choice while the implementation agent keeps working without learning anything that would change how it interprets its task.

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. The shift is at the level of how much tool-call activity the chat surface shows you.

Verbose is the audit view. Every tool call, every read, every write, every thinking pass -- visible. Use it when you are debugging a Claude Code session itself, 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: the high-signal tool calls, the chat, the diffs, without the full firehose of every internal step.

Summary is the review view. It collapses long agent runs into a high-level pass. The intended pattern is to use Summary for a first read of a finished run, identify the spots that need scrutiny, and switch back to Verbose to audit a specific tool call. PR review across a long agent run is the canonical use: skim in Summary, drop into Verbose on the one tool call that looks off.

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.

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.

How the Desktop Integrates With Routines

The desktop and Routines are deliberately complementary surfaces, not competing ones. Routines are configured in the web UI at claude.ai/code/routines. They run on Anthropic's cloud, on a schedule, an HTTP trigger, or a GitHub event. They do not need your laptop to be open.

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 Routines 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. Anthony Morris's launch-day note that he "haven't opened an IDE or terminal in weeks" is the strong-form version of where the surface is pointed: a chat-and-pane window as the primary developer 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 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. If that maps to how you already work, the rebuild lands clean. If it does not, the new sidebar and view modes are still a real upgrade over the single-session app they replaced.