The modern developer's terminal is becoming a crowded space. As agentic coding shifts from single-prompt interactions to complex, multi-step workflows, the friction of management has scaled linearly with the ambition of the tasks. Most engineers currently juggle this by opening a dozen tmux panes or terminal tabs, desperately trying to remember which window is running the refactor, which is writing the unit tests, and which one has been silently stuck on a permission error for the last ten minutes. This cognitive overload creates a paradox where the productivity gained from AI agents is partially offset by the mental tax of orchestrating them.
The Architecture of Parallel Agency
Anthropic is addressing this fragmentation with Agent View, a new feature currently in Research Preview for Claude Code v2.1.139+. Rather than forcing users to manage separate terminal instances, Agent View collapses multiple background Claude Code sessions into a single, unified table. This interface allows developers to launch, monitor, and respond to a fleet of agents from one central hub. Each row in the table represents a distinct session, displaying the agent's name, its current activity, and the timestamp of the last modification.
To make this high-density information digestible, the system employs a specific set of status indicators. An animated ✽ indicates the agent is actively working, either executing a tool or generating a response. A yellow icon signals that the agent needs input, such as a permission grant or a clarifying answer. Dimmed icons represent an idle state where the agent is waiting for input but not explicitly blocked. Green indicates a successful completion, red signals a failure due to an error, and grey shows a session that has been stopped via `Ctrl+X` or the `claude stop` command.
Beyond simple status, the interface tracks process vitality. A ✻ or the working animation confirms the process is alive and ready for immediate interaction. A ∙ indicates the process has died but can be automatically restarted via peek, reply, or attach actions. A ✢ symbol is reserved for `/loop` sessions, showing that the agent is sleeping until the next iteration, complete with an execution count and a countdown timer. To prevent the need for constant transcript diving, the system uses a Haiku-class model to generate one-line summaries of each session's progress, ensuring the developer knows exactly what is happening across ten different tasks at a glance.
The operational workflow is designed for speed. Users can dispatch a new agent by typing a prompt into the bottom input field and pressing Enter, which automatically assigns a name to the session. For quick checks, pressing Space on a session row opens a peek panel to review recent output or PR links. If the agent is asking a multiple-choice question, the user can respond using number keys; for blocked sessions, Tab can be used to send recommended answers. Adding a `!` prefix allows the user to send raw Bash commands directly through the peek panel. When full interaction is required, Enter or the right arrow key attaches the user to the session, where Claude provides a recap of what happened during the user's absence. Detaching is handled by pressing the left or right arrow on an empty prompt, which keeps the session running in the background. To truly terminate a session, the `/stop` command is required.
Power users can leverage several dispatch tricks to route tasks more efficiently. Starting a prompt with a subagent name, such as `<subagent-name> <prompt>`, sets that agent as the lead. Mentioning an agent with `@<agent-name>` or routing to a specific repository with `@<repo>` allows for precise targeting. The `/<skill>` syntax enables the dispatch of packaged repetitive tasks. Furthermore, providing a PR number like `#1234` or a full PR URL will either attach the user to an existing session working on that PR or dispatch a new one. For those who want to bypass the view and jump straight in, `Shift+Enter` performs a dispatch and immediate attach.
Filtering is integrated directly into the dispatch bar. Typing without a command triggers a filter: `a:<name>` filters for sessions running a specific agent, `s:<state>` filters by status (such as `s:blocked` for agents awaiting input), and `#<number>` or PR URLs filter for specific pull request tasks. The system is further supported by a comprehensive set of shortcuts:
- `↑ / ↓`: Move between rows
- `Enter`: Attach to session or dispatch text
- `Space`: Toggle peek panel
- `Shift+Enter`: Dispatch and immediately attach
- `Alt+1~Alt+9`: Attach to the Nth session of a group
- `Ctrl+S`: Switch grouping by status or directory
- `Ctrl+T`: Pin or unpin a session
- `Ctrl+R`: Rename a session
- `Ctrl+G`: Open the prompt in `$EDITOR`
- `Ctrl+X`: Stop a session (double-press within 2 seconds to delete)
- `Shift+↑ / Shift+↓`: Reorder sessions
- `?`: View all shortcuts
For those who prefer the command line, the following shell commands provide direct control:
claude agents # Open Agent View
claude attach <id> # Attach to a specific session
claude logs <id> # View recent output
claude stop <id> # Stop/kill a session
claude respawn <id> # Restart a stopped session
claude respawn --all # Revive all sleeping/shutdown sessions
claude rm <id> # Remove from listThe Supervisor and the Worktree Twist
While the UI is the most visible change, the true technical shift lies in how Claude Code handles state and file system integrity. In a standard AI coding setup, running multiple agents on the same directory is a recipe for disaster, as agents overwrite each other's changes and corrupt the git index. Agent View solves this by implementing automatic isolation via git worktrees. When a session is dispatched from Agent View, the system automatically creates a separate git worktree under `.claude/worktrees/` if edits are required. This ensures that each agent operates in its own isolated environment, preventing file collisions and allowing the developer to review changes in a clean, separated state. These worktrees are deleted when the session is removed, meaning any changes not merged or pushed are lost.
This isolation is managed by a supervisor architecture. Background sessions are not tied to the user's active terminal session; instead, they are children of a user-specific supervisor process. This means that if a developer closes their terminal or the system restarts, the supervisor maintains the state. Completed sessions that have been idle for over an hour have their processes terminated to save resources, but their state is preserved on disk, allowing them to be respawned instantly upon the next connection. The supervisor also handles seamless binary updates, restarting itself with the new version while keeping background sessions alive.
Transparency is maintained through local state files. The supervisor logs are stored in `~/.claude/daemon.log`, the active session roster in `~/.claude/daemon/roster.json`, and individual session states in `~/.claude/jobs/<id>/state.json`. For organizations that require strict control, the feature can be disabled via the `disableAgentView` setting or the `CLAUDE_CODE_DISABLE_AGENT_VIEW` environment variable.
Despite these advancements, the system operates within specific constraints. Parallelism does not come with a discount; running ten agents simultaneously consumes the API quota ten times faster. Because the supervisor runs on the local machine, sessions are paused during system sleep or shutdown. Finally, the tight coupling between sessions and worktrees means that deleting a session without pushing the code results in the permanent loss of that agent's work.
Detailed demonstrations of these workflows can be found in the official showcase: https://youtu.be/-INveHwbRz4.
Claude Code is evolving from a sophisticated chat interface into a full-scale orchestration layer for autonomous engineering.
