21  Redesigning Claude Code on Desktop for Parallel Agents

Originally published April 14, 2026.

21.1 The Shift to Parallel

For most of 2025, developers used Claude Code one session at a time. You opened a terminal, started a session, worked on a task, and when you wanted to do something else, you either finished or abandoned the current session. This was fine when agents were assistants that helped with individual tasks. But as Claude Code evolved into a tool that could autonomously run tests, review PRs, and manage deployments, the one-session-at-a-time model became a bottleneck.

The shift to parallel agents changed everything. Developers wanted to kick off a code review agent while continuing to build a feature. They wanted to run a migration script in one session while debugging in another. They wanted to monitor a long-running deployment while drafting documentation. The terminal-based interface — one process, one window — couldn’t keep up.

The desktop redesign of Claude Code, released in April 2026, was built from the ground up for this parallel world.

21.2 What’s New

21.2.2 Drag-and-Drop Layout

The desktop app uses a drag-and-drop panel layout that lets you arrange your workspace however you want. Panels can be:

  • Docked to the sides of the window
  • Floating as independent windows
  • Tabbed within a panel group
  • Split horizontally or vertically
┌──────────────┬────────────────────┬─────────────────┐
│  File Tree   │   Editor           │   Terminal      │
│              │                    │                 │
│  src/        │   def authenticate │   $ pytest      │
│  ├── auth/   │       (user):      │   PASS          │
│  ├── models/ │       ...          │                 │
│  └── tests/  │                    │   $ ruff check  │
│              │   # Diff view      │   All good      │
│  CLAUDE.md   │   - old_code       │                 │
│              │   + new_code       │                 │
└──────────────┴────────────────────┴─────────────────┘
Tip

Save your layout as a preset. If you always work with the file tree on the left, editor in the center, and terminal on the right, create a “Development” preset. If you prefer a diff-focused layout for code review, create a “Review” preset. Switch between them with a single click.

21.2.3 Side Chats (⌘+;)

Side chats are lightweight conversations that don’t require a full session. Press ⌘+; (or Ctrl+; on Windows/Linux) to open a side chat panel where you can ask quick questions without context-switching away from your main session.

Side chats are perfect for:

  • “What does this function do?” while reading unfamiliar code
  • “How do I configure X?” quick lookups
  • “Generate a regex for this pattern” small tasks
  • “Summarize this file” quick overviews

Side chats share the project context (files, CLAUDE.md) but have their own conversation history. They don’t affect the main session’s context window.

21.2.4 Integrated Terminal

The desktop app includes a fully integrated terminal that runs alongside the agent. This is not a tool the agent uses — it’s a terminal for you. But it’s connected to the same project, so you can:

  • Run tests while the agent works on code
  • Execute builds to check compilation
  • Inspect git state without leaving the app
  • Run any CLI tool in the project context

The terminal shares the same working directory as the agent session, so there’s no friction between what the agent sees and what you see.

21.2.5 In-App File Editor

A built-in file editor lets you view and edit files without switching to an external editor. The editor supports:

  • Syntax highlighting for 50+ languages
  • Inline diff view for agent-proposed changes
  • Multi-cursor editing
  • Find and replace with regex
  • Code folding

You can still use your preferred external editor — the file system is shared — but for quick edits and reviewing agent changes, the in-app editor eliminates context switching.

21.2.6 Faster Diff Viewer

The redesigned diff viewer is significantly faster than the previous version. Large diffs (thousands of lines) render in under a second, with smooth scrolling and instant search.

Key diff features:

  • Syntax-aware diffs that understand language structure
  • Word-level diffs within changed lines
  • Collapse unchanged regions to focus on what matters
  • Side-by-side or inline view modes
  • Accept/reject individual hunks for surgical control

21.2.7 HTML and PDF Preview

For agents that generate web content — HTML pages, PDF reports, SVG diagrams — the desktop app includes inline preview that renders the output without leaving the app.

This is particularly useful for:

  • Frontend development: See HTML/CSS changes rendered instantly
  • Report generation: Preview PDF output from agent-generated LaTeX or HTML
  • Data visualization: View charts and plots inline

21.3 Three View Modes

Different tasks require different levels of detail. The desktop app offers three view modes that control how much agent activity is displayed:

21.3.1 Verbose Mode

Shows everything: every tool call, every intermediate result, every reasoning step. Useful for debugging agent behavior or understanding exactly what happened during a complex task.

[14:23:01] Tool: bash
           Command: git diff HEAD~3
           Output: (247 lines)

[14:23:03] Reasoning: The diff shows changes to the auth
           module. I need to check if the tests cover
           the new token validation logic...

[14:23:05] Tool: file_read
           File: src/auth/tokens.py
           Lines: 45-89

21.3.2 Normal Mode (Default)

Shows key actions and results without every intermediate step. Tool calls are summarized, reasoning is hidden unless relevant. This is the right mode for most day-to-day work.

21.3.3 Summary Mode

Shows only high-level progress and results. The agent’s work is collapsed into a timeline of milestones. Useful for monitoring long-running sessions where you don’t need the details.

✓ Analyzed codebase (14 files)
✓ Identified 3 security issues
✓ Created fix for issue #1
→ Working on fix for issue #2
Mode Best For Detail Level
Verbose Debugging, learning, auditing Everything
Normal Day-to-day development Key actions and results
Summary Monitoring long-running agents Milestones only
Note

You can switch view modes at any time, even mid-session. Switch to Verbose when you want to understand what the agent is doing, then switch back to Summary when you’re satisfied. The mode affects display only — the agent’s behavior doesn’t change.

21.4 Plugin Parity with CLI

The desktop app achieves full plugin parity with the CLI. Any plugin that works in the terminal version of Claude Code works in the desktop app — no modifications needed.

This includes:

  • MCP servers for external integrations
  • Custom tools defined in project configuration
  • Hooks that run on specific events (pre-commit, post-edit, etc.)
  • Themes and visual customizations
  • Skills from the shared skills directory
# .claude/plugins.yml — works in both CLI and desktop
plugins:
  - name: prettier
    event: post-edit
    glob: "*.{js,ts,jsx,tsx}"
    command: "npx prettier --write {{file}}"

  - name: test-runner
    event: manual
    command: "npm test -- --watch {{file}}"

21.4.1 SSH Support for Mac

The desktop app includes SSH support that lets you run agent sessions on remote machines. This is particularly valuable for Mac users who need to:

  • Work with code on a remote development server
  • Run agents in a specific network environment
  • Access GPU resources for ML workloads
  • Maintain sessions across machine reboots
# Connect to a remote machine
claude desktop --ssh user@dev-server.example.com

# The agent session runs on the remote machine,
# but the UI runs locally with full desktop features

The SSH connection is persistent — if your network drops, the session continues on the remote machine and the desktop app reconnects automatically when connectivity returns.

21.5 Workflow Examples

21.5.1 Parallel Feature Development

Session 1: "Implement user preferences API"
  → Agent is writing code, running tests
  → You monitor progress in Summary mode

Session 2: "Review PR #1234"
  → Agent is analyzing the diff
  → You switch to this session when it needs input

Session 3 (Side Chat): "What's the format for the config file?"
  → Quick question, no session overhead

21.5.2 Code Review and Fix

Session 1: "Review the auth module for security issues"
  → Agent identifies 3 issues
  → You review findings in the diff viewer

Session 2: "Fix issue #1 from the review"
  → Agent implements the fix
  → You verify with the integrated terminal
  → Accept the diff hunk by hunk

21.5.3 Long-Running Deployment

Session 1: "Deploy to staging and verify"
  → Agent runs deployment scripts
  → Monitors health checks
  → Reports progress in Summary mode
  → You continue working in other sessions

Session 2: "Continue building the dashboard feature"
  → Your main development session
  → Unaffected by the deployment running in Session 1

21.6 Design Principles

The desktop redesign was guided by three principles:

  1. Parallelism is the default, not the exception. Every feature was designed assuming the user has multiple sessions running simultaneously.
  2. The agent and the human share the same workspace. Files, terminals, and diffs are visible to both. No black boxes.
  3. Detail on demand. Show the minimum necessary by default, but let the user drill down to any level of detail instantly.

21.7 Performance and Resource Management

Running multiple parallel sessions is resource-intensive. The desktop app is engineered to handle this efficiently:

21.7.1 Memory Management

Each agent session maintains its own context, which can consume significant memory when running in parallel. The desktop app uses several strategies:

  • Context compression: Sessions in Summary mode use compressed representations, reducing memory footprint by up to 70%.
  • Session hibernation: Sessions that have been idle for extended periods are hibernated — their state is saved to disk and restored when reactivated.
  • Smart caching: Tool results and file contents are cached across sessions when they access the same resources.

21.7.2 Network Efficiency

Parallel agents can generate significant network traffic. The desktop app optimizes this through:

  • Connection pooling: API requests share persistent connections, reducing overhead.
  • Request batching: When multiple sessions make similar requests, they can be batched.
  • Delta synchronization: Only changes are synced, not full session state.
Sessions Running Typical Memory Network Bandwidth
1-3 ~500MB Low
4-6 ~1.2GB Medium
7-10 ~2GB Medium-High
10+ ~3GB+ High
Note

If you regularly run more than 8 concurrent sessions, ensure your machine has at least 16GB of RAM. The desktop app will warn you if resource usage is affecting performance, and can automatically hibernate the least recently used sessions to free resources.

21.8 Key Takeaways

  • The desktop redesign is built for parallel agents, with a sidebar that manages multiple concurrent sessions.
  • Drag-and-drop panels let you arrange your workspace — file tree, editor, terminal, diff viewer — however you want, with layout presets for common workflows.
  • Side chats (⌘+;) provide lightweight conversations for quick questions without the overhead of a full session.
  • An integrated terminal runs alongside the agent, sharing the project context for seamless human-agent collaboration.
  • The in-app file editor with syntax-aware diffs lets you review and edit agent-proposed changes without context switching.
  • Three view modes — Verbose, Normal, and Summary — let you control how much agent activity is displayed, switchable at any time.
  • Full plugin parity with the CLI means MCP servers, custom tools, hooks, and skills work identically in both environments.
  • SSH support for Mac enables remote agent sessions with local desktop UI, persistent across network interruptions.