Claude Code Agent View: Anthropic launches the dashboard that kills the split-screen terminal

Claude Code Agent View: Anthropic launches the dashboard that kills split-screen terminals

🔎 Multiple agents, a single terminal — finally

Anthropic just solved a problem every agentic developer knows: split-screen chaos. When you launch three Claude Code sessions in parallel, your terminal looks like a broken nuclear power plant control room.

Agent View, announced on May 11, 2026, changes the game. It's a unified CLI dashboard that centralizes the supervision, interaction, and monitoring of all your parallel agent sessions — without leaving your terminal.

The timing is no coincidence. Cursor 3 is pushing its Agents Window, JetBrains just unveiled Air, and GitHub Copilot is activating its agent mode. The agentic coding battle is entering its industrialization phase. And Anthropic is taking the lead on the terrain where Claude Code is strongest: the terminal.

The essentials

• Agent View is an official CLI dashboard to manage all parallel Claude Code sessions from a single interface, accessible via the left arrow or the claude agents command.
• The architecture relies on a supervisor agent that dispatches tasks to parallel subagents (forks), each with its own isolated context but inheriting the system prompt, tools, and model.
• Claude Code consumes 5.5x fewer tokens than Cursor on equivalent benchmarks (33K vs 188K tokens), an advantage amplified by Agent View which optimizes multi-agent coordination.
• Rakuten has already reduced its feature delivery lead time from 24 to 5 days thanks to parallel Claude Code sessions — Agent View is the interface that makes this workflow scalable.
• The feature is part of a broader update including dreaming (inter-session memory refinement), outcomes self-grading, and persistent memory.

Recommended tools

To choose the right underlying model, check out our comparison of the best LLMs for coding in 2026.

How Agent View works — anatomy of the dashboard

Agent View is not just another TUI (Terminal UI). It's a supervision layer built around a very specific pattern: the supervisor.

The supervisor agent

The concept is documented in the official Claude Code subagents doc. A supervisor agent is automatically launched when you activate Agent View. Its role: to coordinate multiple parallel sessions without you having to juggle between tabs.

Each subagent (called a "fork" in Anthropic terminology) inherits the parent system prompt, available tools, selected model, and conversation history. But it operates in an isolated context. No state collisions, no file conflicts.

In practice, you give a global objective to the supervisor. It breaks it down, creates the necessary forks, and launches them in parallel. You track the progress in Agent View.

Key commands

Two entry points to access the dashboard:

• Left arrow from any active Claude Code session
• claude agents command from the terminal

Once in Agent View, you use /goal to define the supervisor's objective. Navigation commands allow you to zoom in on a specific agent, take back control, or kill a fork that's spinning out.

The interface displays the state of each agent (in progress, pending, completed, error), the tokens consumed per session, and partial results. It's a war dashboard, not just a process list.

Parallel sessions: what actually changes

Before Agent View, launching 3 agents in parallel meant 3 terminal tabs, 3 tmux windows, or an unreadable split-screen. You had to memorize which agent was doing what.

With Agent View, the supervisor handles this complexity. Pasquale Pillitteri describes in detail how agent states are centralized: each fork reports its status to the supervisor, which aggregates it in the dashboard.

The gain isn't just visual. It's structural. An agent that gets stuck doesn't prevent the others from continuing. The supervisor can reallocate tasks. It's orchestration worthy of a distributed system — but in your terminal.

The subagents architecture: forks, isolation, and parallelism

To understand the power of Agent View, you need to grasp the underlying architecture that Claude Code introduced.

What a fork is

A fork is a copy of your Claude Code session at a given point in time. It inherits everything: the system prompt, tool configuration, active model, history. But it evolves in its own context.

The isolation is total. If fork A modifies app.py and fork B works on tests.py, there is no risk of context conflict. Each fork has its own token window, its own reasoning.

True parallel execution

Forks are not disguised sequential processes. Anthropic actually executes them in parallel. At the Code with Claude 2026 conference, Anthropic presented "agent teams": a manager agent delegates to parallel workers, each specialized in a task.

It's this architecture that Agent View makes observable and controllable. Without the dashboard, parallel execution exists but remains opaque. With it, you have the visibility needed to intervene.

The /goal command as an entry point

/goal is the central command of Agent View. You type it in the dashboard, describe your objective in natural language, and the supervisor breaks it down.

For example: /goal Refactor the authentication module to use OAuth 2.1, add unit tests, and update the API documentation. The supervisor can create three forks: one for the refactoring, one for the tests, one for the docs. Each works independently. You track everything from Agent View.

This pattern is similar to what projects like ByteDance's DeerFlow are exploring in open-source — an agent that plans, delegates, and executes over the long term. But here, it's native, integrated, and production-ready.

Agent View vs Cursor 3 vs JetBrains Air — who wins the agentic battle?

The coding agent market is in full consolidation. Three approaches are clashing in May 2026, and comparisons are multiplying.

Claude Code: the terminal as a competitive advantage

Claude Code starts from a counter-intuitive premise: the terminal is a better environment for agentic coding than the IDE. And the numbers prove it right.

According to a Tech Insider analysis, Claude Code consumes 33K tokens for a benchmark where Cursor consumes 188K. A 5.5x gap. Fewer tokens mean lower costs, faster responses, and above all, a context less polluted by the visual noise of the IDE.

Agent View compensates for the main criticism leveled at the terminal: the lack of visibility into parallel processes. The dashboard adds the interface layer that was missing.

Cursor 3: the visual approach

Cursor 3 introduced the Agents Window — a side panel in VS Code that displays active agents, their actions, and their results. It's a "visual-diff" approach: you see changes file by file.

The problem: Cursor remains locked in the VS Code/JetBrains ecosystem. NxCode confirms this: Cursor's typical context window is 128K-256K tokens, and the tool only works with these editors.

If you code in Neovim, Helix, or a custom editor, Cursor won't help you. Claude Code, via the terminal, is agnostic.

JetBrains Air: the new entrant

JetBrains Air represents the historic editor's attempt to offer a native integrated agent. The approach is appealing on paper: an agent that intimately knows the structure of your IntelliJ projects.

But in May 2026, Air is still in a maturation phase. Its parallel agent architecture is less mature than Claude Code's, and the JetBrains ecosystem, while powerful, is a silo.

The comparison table

SitePoint sums up the dynamic well: Claude Code rewards terminal fluency, Cursor rewards visual-diff workflows, and Copilot rewards existing GitHub investment. The clear trend is towards agentic — but the paths diverge.

For an overview of available tools, our page on the best AI tools for code covers the full landscape.

The 5 new agentic features of Claude Code (May 2026)

Agent View is not isolated. It is part of a batch of 5 features launched around the Code with Claude 2026 conference. MindStudio put together a summary.

1. Agent Teams (manager + workers)

This is the engine behind Agent View. A manager agent receives the objective, breaks it down into tasks, and distributes them to parallel workers. Each worker is a fork with its own isolated context.

2. Outcomes Self-Grading

Agents evaluate the quality of their own work before submitting it. If a fork considers its result insufficient, it can iterate without human intervention. This drastically reduces the rate of "false positives" where an agent announces it has finished while the code is broken.

3. Dreaming (research preview)

Anthropic describes dreaming as a memory refinement mechanism between sessions. The agent "dreams" — meaning it reorganizes and consolidates its learnings when idle. In practice, an agent that has fixed a race condition bug in a project will be more efficient on similar problems in subsequent sessions.

4. Persistent memory

Claude Code sessions are no longer ephemeral. The agent retains inter-session memories: coding preferences, project patterns, past errors. Agent View benefits directly from this memory — the supervisor knows which strategies have worked in the past.

5. Multiagent Orchestration (public beta)

The most advanced version of the supervisor architecture. A lead agent dispatches to parallel specialist subagents, each configured with a specific prompt and tools. This is the production version of what agent teams are experimenting with.

Token efficiency: why using 5.5x fewer tokens than Cursor changes everything

The figure is striking. Tech Insider measured it: on the same benchmark, Claude Code consumes 33K tokens, Cursor 188K.

Where does the gap come from?

Cursor injects a massive amount of visual information into its context: the content of open tabs, editor diagnostics, inline decorations, filesystem state. All of this is tokenized and sent to the model on every turn.

Claude Code, operating in the terminal, only sends what is necessary: the targeted code, the command, the result. No UI overhead. The context remains clean and targeted.

Agent View amplifies the advantage

When you manage 3 agents in parallel in Cursor, each consumes its own IDE context. You multiply the overhead by the number of agents.

With Agent View, the supervisor optimizes task distribution and information sharing between forks. A fork doesn't need to rebuild the complete project context — it inherits what the supervisor deems relevant. The token savings are exponential with the number of agents.

What this means for your bill

If you use Claude Opus 4.7 (Anthropic's most performant agentic model with a score of 94.3), every token counts. A 5.5x gap on a benchmark translates to hundreds of dollars in savings per month for a team of 5 developers in intensive use.

The choice of model remains crucial. Claude Sonnet 4.6 (score 81.4) offers an excellent quality/price ratio for less complex tasks, while OpenAI's GPT-5.5 (score 98.2) tops the agentic rankings but at a higher cost.

Concrete use cases: when Agent View changes your life

Monolithic module refactoring

You have a 2000-line module to split into 4 services. With Agent View: /goal Split the payment module into gateway, processor, validator, and notifier services. Four forks launch in parallel, each with its own subset of files. You monitor from the dashboard.

Without Agent View, you would do this sequentially or with four terminals side by side, copy-pasting the results manually.

Multi-service parallel debugging

An integration test fails intermittently. Three services are involved. You launch three forks, each attached to a service, with the objective of reproducing the bug within its scope. Agent View aggregates the findings.

Large-scale dependency updates

Updating 15 dependencies with their breaking changes. Each fork handles a subset of dependencies, runs the associated tests, and reports conflicts. The supervisor identifies cross-dependencies and reallocates if needed.

This is the type of workflow that allowed Rakuten to go from 24 to 5 days of delivery lead time. Agent View makes this pattern accessible without a dedicated platform engineering team.

What remains limited — Agent View's blind spots

Still no GUI

Agent View is a CLI dashboard. If you're not comfortable in the terminal, this is not for you. Anthropic is showing no signs of a graphical interface for Claude Code — it's a philosophical choice, not a lack of resources.

Dreaming is still in preview

Inter-session memory via dreaming is experimental. Anthropic clearly positions it as research preview. Don't rely on it in production for now.

The cost of parallel sessions

Launching 5 forks in parallel with Claude Opus 4.7 can generate significant bills. Even with Claude Code's token efficiency, parallelization has a price. You need to calibrate the number of forks based on the actual complexity of the task.

Ecosystem compatibility

Claude Code works anywhere there is a terminal. But it doesn't have the deep integration that Cursor or JetBrains have with their respective IDEs: no inline diagnostics, no visual refactoring preview, no integrated code navigation. You gain in agentic, you lose in classic DX (developer experience).

Projects like DeepSeek-TUI are exploring similar approaches in open-source, showing that the agentic terminal is a fundamental trend — but the UX still needs refinement.

How to properly configure Agent View — best practices

Choosing the right model per task

Not all forks need the same model. For the supervisor, Claude Opus 4.7 (score 94.3) is justified — it must understand and break down complex objectives. For workers executing mechanical tasks (renaming, formatting, basic tests), Claude Sonnet 4.6 (score 81.4) is more than enough and costs much less.

GPT-5.5 (score 98.2) can be relevant for extreme reasoning tasks, but the extra cost compared to Opus 4.7 is not always justified in a multi-agent workflow where the supervisor absorbs a significant share of the tokens.

Limiting the number of forks

The temptation is strong to launch 10 forks to go fast. In practice, beyond 4-5 parallel forks, the supervisor spends more time coordinating than producing. Start with 2-3 forks, increase gradually.

Using checkpoints

Our article on Code Execution and Checkpoints in Hermes Agent explores a similar pattern: saving intermediate states to be able to go back. The same principle applies to Agent View. If a fork goes in the wrong direction, kill it and relaunch it — don't let a drifting agent consume tokens unnecessarily.

Combining with suitable hosting

An intensive multi-agent workflow requires a machine with enough RAM and CPU. If you host your projects with Hostinger, check that your plan supports multiple parallel Node.js/Python processes without throttling.

❌ Common mistakes

Mistake 1: Launching Agent View without a clear objective

Typing claude agents then looking for what to do. Agent View is an execution tool, not an exploration tool. Define your /goal before opening the dashboard, not after.

Mistake 2: Using Opus 4.7 for all forks

This is the fastest way to drain your budget. The supervisor in Opus, the workers in Sonnet. Reserve high-end models (GPT-5.5, Claude Opus 4.7) for tasks that require deep reasoning.

Mistake 3: Ignoring self-graded results

When a fork reports that its result is "partially satisfactory", don't ignore it. Self-grading outcomes are designed to catch problems before they spread to other forks. Intervene early.

Mistake 4: Confusing parallelism with speed

Five forks does not mean five times faster. Decomposition has a cost, coordination has a cost, merging results has a cost. On a simple task (a single file, a trivial change), a single agent is faster.

❓ Frequently asked questions

Is Agent View available for free?

No. Agent View is part of Claude Code, which requires a Claude Pro plan at a minimum of $100/month (May 2026, check on claude.com). The token costs of parallel sessions are added to this subscription.

Can models other than Claude be used under Agent View?

No. Claude Code is tied to the Anthropic model family. To use GPT-5.5 or Gemini 3 Pro Deep Think, you need to go through Cursor or a multi-model tool. Consult our Claude vs ChatGPT comparison for the nuances.

Does Agent View replace tmux?

Partially. You no longer need tmux to manage your parallel Claude Code sessions. But you can still use tmux for other tasks (logs, servers, etc.) alongside Agent View.

How many forks can be launched in parallel?

There is no documented hard limit, but Anthropic recommends staying under 5-6 active forks to maintain supervisor efficiency. Beyond that, the gains from parallelism diminish.

Is dreaming enabled by default?

No. Dreaming is in research preview and requires manual activation. It should not be used in production without validation of inter-session results.

✅ Conclusion

Agent View transforms Claude Code from a solo coding agent into a true parallel agent orchestrator — all from a CLI dashboard that TechnoSports describes as the end of "terminal chaos". With 5.5x fewer tokens consumed than Cursor and a supervisor architecture proven by Rakuten in production, Anthropic is not just launching a simple UI feature: it is imposing the terminal as the legitimate playground for agentic coding. If you master the command line, it's time to switch to Claude Code.