Picture five or six Claude Code sessions running at once, each in its own terminal tab. One is writing code, another is waiting for you to approve something, a third has just finished — and you're clicking between tabs, no longer sure which is doing what. I know that mess, and the agents view was built precisely for it. I'll show you what it is, how to work it step by step, and at the end I'll mention the recent /goal command, which pairs nicely with it.
Two terms first, so we're talking about the same thing. A session is one conversation with Claude Code about a specific task — the agent reads files, writes code, fixes its own errors along the way. Parallel sessions (or concurrent ones) are several such conversations running at the same time, each on something different. And the terminal (the CLI, or command-line interface) is the black window where you type commands as text instead of clicking buttons. It sounds austere, but that's where Claude Code has the most capability — and it's the only place the agents view works.
Where the mess comes from
When you start many sessions at once, each lands in its own terminal tab. After a few, it stops being clear which is which. You approve a plan in one, and a moment later you're hunting for the one that's now waiting on your input — and losing time to it.
Anthropic eased this earlier with what's called a recap. At the end of each session you'd get a short note about what you'd been working on — quite helpful. But it was still a summary of a single tab, not a view of the whole at once.
What the agents view is
The agents view arrived on 2026-05-12 and is, for now, in research preview — that is, an early version Anthropic releases ahead of time, which can still be unstable here and there. Even so, I'm genuinely pleased with it, because it solves exactly this problem.
It's a single view holding all your sessions at once. You step into any one, watch what's happening, step back out to the list, and jump to the next — all from one terminal tab. Instead of ten tabs and guesswork, you have one place to manage them from.
The strongest part is that the statuses are visible at a glance:
- a session that's working — getting on with it, nothing for you to do;
- a session waiting on your input — it lights up amber, because it needs a decision from you (asking you to approve a plan, say, or for an answer);
- a finished session — it turns green and drops to the bottom of the list.
So you know straight away where to direct your attention: the amber session is waiting on you, the rest will manage on their own.
One caveat: the agents view works only in the terminal, not in the code-editor extension (for VS Code, say). If you've stuck with the extension so far because it feels friendlier — relax, the terminal doesn't bite, and it usually just has the most capability. It's worth pushing yourself to try it.
How to work it
It reads like a long list of commands, but in practice two or three moves are all you need. The rest are fallbacks.
Navigating with the arrows. From within any session, you press the left arrow — and the agents view opens with a list of all sessions. To step into a specific one, you land on it and press the right arrow. To return to the list — left again. You move around the list itself with the up and down arrows, or simply with the mouse.
Starting a new session. The simplest way: once you're in the agents view, you just type a description of the task — and that starts a new session right away. Nothing more needed.
There are also commands that do this manually, in case they come in handy in a particular situation:
/bg(short for "background") — drops the current session into the agents view. In practice, sessions almost always land there on their own, so/bgis a fallback for those rare times one doesn't.claude --bg "task description"— starts a new session straight in the background, in the agents view. A small catch in this early version: the description has to be in quotes. Square brackets don't work.claude agents— opens the agents view in a freshly started terminal.
Two actions are worth committing to memory separately:
- Deleting a session. You select it in the list and press Ctrl+X twice — that closes it.
- Answering a session that's waiting. When you see an amber session with a question, you press space, type your answer, and send it — straight from the view, without stepping into the session itself.
That's all you need for day-to-day work. If this list of commands feels overwhelming, don't worry — most of the time you'll just be hopping around with the arrows and typing in the next task.
When you're juggling several projects
This is where the manual commands earn their keep. You keep each project in its own directory (a folder on disk). If you start a session while you're in a given directory, it gets assigned to that project. So you can move to another directory, start a session there — and in the agents view you have sessions from different projects side by side. Handy when you're running several things in parallel.
There's one limitation, typical of so early a version: the list doesn't yet make it easy to see which directory a given session is sitting in. You can check by stepping into the session, but it isn't there at a glance. I expect that to come in time.
Anthropic pointed to four common patterns for using the agents view. Among them, two worth naming outright: scaling the number of parallel sessions — running an ever-larger number of tasks at once — and managing long-running agents, the ones that work on a single task over an extended stretch.
An aside: the /goal command
And here's where /goal comes in — a separate, also recent command that ties in neatly with the agents view. It's a digression, since this article is about the view itself, but it's worth knowing.
Instead of giving Claude Code a single instruction, you set a goal, and the agent experiments on its own, trying different approaches until it reaches it. It can work for hours, overnight too, and comes back only once the goal is met. It works much like the "goal" feature in Codex — the familiar loop known as "Ralph Wiggum": try, check, fix, repeat.
One thing decides whether it works: the goal has to be measurable. It's a bit like automated, Karpathy-style research — you optimize toward a specific metric you can check unambiguously. "Build me a game" is too vague; the agent doesn't know when to call the task done. In practice /goal is a one-shot prompt — a single instruction for the whole, long run — so the quality of that instruction is critical. The more precisely you describe what you're aiming for and how to recognize success, the better the result.
The link to the agents view is simple: /goal sessions can be long, so it's good to have them in one panel, where you can watch and manage them calmly, instead of keeping an eye on each in its own tab.
What to expect, and what follows from it
Remember that this is a research preview — it can have bugs. On my machine, the first launch made the computer lag for a moment. Don't treat it as a version meant to work flawlessly; treat it as early access to something that makes sense.
And if, after all this, you don't see the value in the agents view — that probably means you're not running many sessions at once. Which is to say you're not yet using Claude Code as your operating system for work, but as a single helper. That's a perfectly fine place to start. But once you begin running several tasks in parallel, you'll quickly feel that working with agents in parallel needs one command center, not ten scattered tabs.
The simplest next step: next time you have a session open, press the left arrow and look around. The rest will explain itself once you start working in this view.