Claude Code Agent View: One CLI, Many Sessions

What changed

Anthropic has shipped Agent View as a research preview in Claude Code. It is the first feature that treats the CLI as a session orchestrator rather than a single conversation. You can dispatch several agents from the same terminal, send each to the background, peek at status and last response, and only foreground a session when the agent has a question you need to answer. Fast mode now defaults to Opus 4.7 (previously Opus 4.6), the plugin marketplace surfaces projected context cost before you install, and PowerShell is enabled by default on Windows for Bedrock, Vertex and Foundry users.

If the recent Claude Code /autopilot upgrade turned one Claude into a long-running co-worker, Agent View is the move from co-worker to small team. The mental model is no longer "the agent" — it is "the bench", and your job at the keyboard is to triage who needs you.

• Agent View is a layer above sessions, not a new model — it is to Claude Code what tmux is to a shell.
• Background dispatch happens via claude agents with a new set of configuration flags.
• Worktree isolation is now optional — flip worktree.bgIsolation: "none" for repos where worktrees do more harm than good.
• Plugin dependency enforcement is sharper — disabling a plugin that others depend on is refused with a copy-pasteable disable-chain hint.

Agent View is not /autopilot

This is the bit teams keep getting wrong in the first week. Autopilot is a mode on a single session — it tells one Claude to push through to a goal with fewer permission prompts. Agent View is an orchestrator for many sessions, each of which may or may not be on autopilot. You can absolutely dispatch four autopilot agents, but Agent View is the thing that lets you see all four at once and pick the one to context-switch into.

For a Bangalore product team that has been running a single autopilot session and feeling slightly disappointed, the upgrade path is obvious. Stop running one Claude on one branch — instead, split the next sprint's six tickets into six background dispatches before stand-up, then drop into the orchestrator after lunch to clear the queue. For a London consultancy juggling three client deployments in parallel, the analogous play is one background agent per client environment, each with its own --add-dir and --settings profile, and a single human triaging.

The new flags — a practical how-to

The claude agents subcommand now accepts a configuration surface that is wide enough to be its own mini language. Here is a representative dispatch from a real overnight refactor.

# Dispatch a background agent against a sibling worktree,
# pinned to Opus 4.7 with medium effort, and an MCP config
# that gives it Postgres + GitHub tools only.

claude agents \
  --add-dir ../webapp-refactor \
  --settings ./.claude/refactor.settings.json \
  --mcp-config ./.claude/mcp-postgres-github.json \
  --plugin-dir ./.claude/plugins/repo-surgery \
  --permission-mode auto-tools-only \
  --model claude-opus-4-7 \
  --effort medium \
  -- \
  "Rename the deprecated UserSession API across the monorepo, \
   thread the new auth header through middleware, \
   and open a PR with passing CI."

The flag list reads long but every entry earns its place. --add-dir points the agent at the directory it should treat as its working copy. --settings and --mcp-config let you ship per-task tool surfaces — useful when one agent should not see your production secrets and another should. --plugin-dir pulls in a curated set of plugins for the job, which pairs nicely with the new plugin marketplace browse pane that now shows projected context cost as per-turn and per-invocation token estimates. Knowing that a fancy code-review plugin adds 18k tokens per invocation is the kind of information that turns "looks useful" into "actually useful".

--permission-mode is the one to get right. Pick the policy you trust for unattended work, because the agent will sit waiting for input the moment it encounters a permission boundary the mode does not auto-resolve — and a sitting agent is what foregrounds the session in Agent View. --model and --effort are the usual tuning knobs; pair Opus 4.7 with high effort for the gnarly stuff, Sonnet with medium for the boilerplate. --dangerously-skip-permissions exists for the cases where you have already isolated the blast radius another way — sandbox container, throwaway worktree, no network — and want the agent to plough through without asking. The flag name is honest about the trade.

Worktrees, plugins and the smaller wins

Two other changes will quietly improve your week. First, worktree.bgIsolation: "none" is the setting that finally addresses the long-standing complaint that EnterWorktree is the wrong default for some repos. If your monorepo has gigabytes of build artefacts, brittle pre-commit hooks, or a path-sensitive native binary cache, every EnterWorktree dispatch was a tax. Setting bgIsolation to none lets background sessions edit the working copy directly. The trade-off is real — concurrent agents in the same working copy can step on each other — but for repos where worktrees were impractical, this finally makes Agent View viable.

Second, plugin dependency enforcement now behaves the way you would assume it should. claude plugin disable refuses if another enabled plugin depends on the target, and prints a copy-pasteable command that disables the entire chain. claude plugin enable goes the other way — force-enables transitive dependencies so you do not get the surprise "missing dependency" error half-way through a task. Combined with the new context-cost preview in the marketplace browse pane, plugin hygiene becomes a thing you can reason about rather than a soft pile of yak.

Workflow shape	Best tool today	Why
Six feature branches overnight	Agent View + worktrees	Native parallelism, each branch isolated
Three client deployments in parallel	Agent View + per-client settings	One human triages instead of three
Short IDE-grounded edits	Cursor 3 parallel agents	Tighter editor loop, shorter turns
Single long autopilot run	Claude Code /autopilot	Agent View adds no value for one session
Managed cloud orchestration	Anthropic Managed Agents	Agent View is local; Managed Agents is hosted

Cost economics — the bit nobody talks about

Multi-agent dispatch is the easiest way to set fire to a model budget. Each background agent is a real session burning real tokens, and four parallel Opus 4.7 sessions can hit your monthly cap faster than the autopilot upgrade did. The mitigations are the usual ones with sharper edges: prompt caching is essential and benefits enormously from a shared --settings file across dispatches (because the cache key includes the system prompt); per-agent --effort tuning matters more when you are running four at once; and the projected context cost shown in the plugin browse pane should be treated as load-bearing, not decoration.

For teams that have already absorbed the Opus 4.7 1M context release, Agent View is the feature that finally puts that context to work. A single agent reading 800k tokens of monorepo is impressive; four agents each reading their slice and merging output is a different category of productivity. The cost picture follows the same logic — cached, parallel, scoped — and any team that figured out the economics of Opus 4.7 for one-at-a-time work will adapt within a sprint.

Where it sits in the wider agent-SDK picture

Agent View lands in a market that is consolidating fast. OpenAI's Agents SDK leans hosted-and-managed; Google's Vertex agent surface is a managed-runtime story; Anthropic has been building both — the hosted Managed Agents beta and now Agent View as the local-first answer for builders who live in the CLI. The full landscape is mapped in our agent-SDK wars piece; the relevant point for today is that Anthropic is the only vendor giving you a first-class local orchestrator that does not require you to deploy anywhere.

For Indian builders shipping under a tight AWS bill, that local-first stance is decisive — Agent View costs nothing beyond the tokens it consumes, with no hosted-runtime markup. For UK consultancies billing time on client environments, the same property removes a procurement hurdle, because nothing leaves the client laptop. Cursor 3's parallel agents remain the right choice for tight IDE-grounded edits, but for longer infrastructural work — dependency upgrades, CI repair, security audits — Agent View now leads.

What it does not yet do

1. No cross-session memory. Each background agent has its own conversation. If you want them to share learnings, that is a plugin or a shared MCP server you build yourself.
2. No auto-merge. The orchestrator surfaces conflicts; you resolve them. Fine for disciplined teams, painful for chaotic ones.
3. Context switching still hurts. Agent View reduces the number of times you switch, but each foregrounded session still demands a rebuild of mental state. Tools can only do so much.
4. It is a research preview. Expect flag names to move, expect rough edges, and pin your dispatches to the published changelog version rather than treating today's behaviour as stable.

So — should you adopt?

If your team already runs more than one Claude Code session at once on different terminals, Agent View is a straight upgrade — turn it on this week. If you ship from a single autopilot session and like it that way, Agent View adds nothing today; revisit when you have a workload that wants parallelism. If you are on a Bedrock, Vertex or Foundry deployment on Windows, the PowerShell-by-default change is worth a separate look — it removes a friction point that pushed many teams to WSL.

For the full release notes, see the official Claude Code changelog and the GitHub releases page. Simon Willison's independent coverage is the most useful third-party write-up if you want a non-Anthropic perspective on the orchestration model.