Claude Code: Features, Benchmarks and Pricing

Claude Code began life as a single-session assistant living in a terminal. You gave it a task, it read your files, proposed edits, ran commands and reported back. That model was already good enough to change how a lot of people worked, but it had a hard ceiling: one conversation, one context window, one thing happening at a time.

Everything Anthropic shipped in the first quarter of 2026 attacks that ceiling from a different angle. Agent teams break the single-session constraint by running several Claude instances in parallel. Claude Code Security breaks the "you have to ask" constraint by scanning a codebase on its own initiative. Code Review breaks the human-in-the-loop bottleneck by attaching agents to every pull request that opens. Each is a different answer to the same question: what happens when you stop treating the model as a chat partner and start treating it as capacity?

The practical consequence is that the interesting decisions moved up a level. In 2025, the skill was writing a good prompt. In 2026, it is deciding how many agents a task warrants, what each one is allowed to touch, and how you verify work that several of them produced simultaneously. That is closer to engineering management than to prompting, and it is why the features below matter more than their individual changelog entries suggest.

If you are pricing this up rather than evaluating it, our Claude Code pricing breakdown covers how the plans and usage limits interact.

Agent teams shipped alongside Opus 4.6 on 5 February and represent a fundamental shift in how Claude Code works. Instead of a single AI session handling tasks sequentially, you can now spin up multiple Claude instances that work together in parallel, each with its own context window and focus area.

One session acts as the team lead, coordinating work, assigning tasks, and synthesising results. Teammates work independently and, critically, can communicate directly with each other. This is the key difference from subagents, which have been available for a while. Subagents run within a single session and can only report back to the main agent.

Agent Teams vs Subagents

How Agent Teams Are Meant to Be Used

The intended shape is a lead agent that decomposes a task and hands specialised roles to teammates: one on the frontend, one on backend logic, one on tests and error handling. Each teammate holds its own context, so a large refactor no longer has to fit inside a single window, and because teammates message each other directly, the one writing tests can ask the one writing the API what the response shape actually ended up being.

Agent teams shipped as an experimental capability and are disabled by default, which is the right call. Parallel agents editing the same repository is a concurrency problem wearing a friendly interface, and the failure modes are unfamiliar: two agents fixing the same bug in incompatible ways, or a teammate confidently building against an interface another teammate has just changed. Anthropic has spent much of the 2.1.x cycle tightening exactly these edges, including fixing cases where a teammate's final answer never reached the team lead.

The feature landed alongside Opus 4.6 on 5 February 2026, and the pairing is not coincidental. Opus 4.6 brought a one-million-token context window to Claude Code, which is what makes it practical for a lead agent to hold a whole architecture in mind while teammates work on pieces of it.

Claude Code Security launched on 21 February 2026 as a limited research preview. It scans codebases for security vulnerabilities and suggests targeted software patches for human review.

What distinguishes it from a conventional scanner is the approach rather than the output. Traditional tools match code against a catalogue of known vulnerability signatures. Anthropic's pitch is that Claude reads and reasons about the code the way a human security researcher would, following how components interact and tracing how data moves through an application, which is how you find the class of bug that no signature exists for yet.

The capability is backed by real results. Using Claude Opus 4.6, Anthropic's team found over 500 vulnerabilities in production open-source codebases, including 14 high-severity bugs in Firefox.

The Firefox Results in Detail

The Mozilla partnership is the best-documented test of the tool so far, and the numbers are worth stating precisely. Over a two-week period in January 2026, Claude identified 22 new vulnerabilities in Firefox: 14 rated high severity, seven moderate and one low. The issues were addressed in Firefox 148. Anthropic's own framing of the significance is that the high-severity count represents almost a fifth of all high-severity vulnerabilities patched in Firefox across the whole of 2025.

One finding illustrates both the promise and the limits. Claude surfaced a use-after-free bug in the browser's JavaScript engine after roughly twenty minutes of exploration, which a human researcher then validated in a virtual machine to rule out a false positive. But when the same model was asked to develop working exploits, it managed only crude ones, in a small number of cases, inside a test environment that had deliberately had protections such as sandboxing stripped out. Finding the bug and weaponising it remain very different problems.

Access is limited to Enterprise and Team customers, with expedited free access offered to maintainers of open-source repositories. That last detail is the one most likely to matter for the wider ecosystem, since decades-old bugs in widely depended-upon libraries are exactly the category Anthropic says the tool is good at surfacing.

Code Review launched on 9 March 2026 as a research preview for Team and Enterprise customers. It is a multi-agent code review system that dispatches teams of AI agents to examine every pull request for bugs.

The agents are specialised rather than identical. When a pull request opens, several are dispatched at once and each targets a different class of problem: logic errors, boundary conditions, API misuse, authentication flaws, and compliance with the conventions of that specific project. Running them in parallel is what makes the multi-agent design worth the token cost, because a single reviewer holding all five concerns at once tends to do all of them adequately and none of them well.

Anthropic's internal data is the most interesting claim attached to the feature: 54% of pull requests now receive substantive comments, against 16% under its previous approach. That is a statement about review coverage rather than about bug-catching accuracy, and it is worth reading carefully. More comments is not automatically better; a reviewer that comments on everything trains people to ignore it. The number that would settle the argument, escaped defects per release, is not one Anthropic has published.

Two limits are worth knowing before you plan around it. At launch the integration was GitHub-only, with no support for GitLab, Azure DevOps or Bitbucket. And the pricing is token-based, so the $15-$25 (£12-£20) figure is an average rather than a cap: a sprawling pull request touching forty files will cost considerably more than a two-line fix. Teams that merge frequently and in small increments will find the economics far kinder than teams that batch a week of work into one enormous branch, which is a helpful incentive to have accidentally created.

Headline features get the announcements, but the day-to-day experience of Claude Code is shaped by the point releases. The 2.1.x line through 2026 has been dominated by three themes: making agent teams survivable, making skills manageable, and giving organisations control over what a developer's Claude Code can connect to.

• Agent observability. A recent release added an agent map to the VS Code extension, showing how many agents are running, a card per agent, a stop control and read-only transcripts. Parallel agents you cannot watch are parallel agents you cannot trust, so this is less cosmetic than it sounds.
• Worktree isolation. Several releases hardened git worktree isolation, including parallel checkout to speed up startup on large repositories, and fixes for isolated sessions that were refusing ordinary shell constructs such as loops and piped xargs commands.
• Skill hygiene. A /skill-doctor command now reports which skills are going unused and what each one costs in context, which turns skill pruning from guesswork into a measurement. Anyone who has watched a context window fill up with instructions nobody is using will recognise the problem.
• MCP governance. Administrators gained a managed setting for deploying HTTP and SSE MCP servers organisation-wide, alongside a separate control governing only the servers individual users add themselves. For regulated teams, that distinction is the difference between being able to adopt Claude Code and not.
• Voice and internationalisation. Speech-to-text support doubled from ten languages to twenty, and prompt suggestion handling improved for Japanese, Chinese and Korean text.

None of these would justify a blog post on their own. Together they describe a product moving from "impressive demo" to "thing an enterprise security team will sign off on", which is a less exciting transition and a more commercially significant one.

A few things consistently separate teams that get leverage out of the 2026 feature set from teams that generate a lot of tokens and not much progress.

Do not reach for agent teams by default. Parallelism pays when a task genuinely decomposes into independent pieces with clean interfaces between them. It costs when the pieces are entangled, because you inherit coordination overhead and merge conflicts in exchange for very little wall-clock saving. A single session with a long context is still the right tool for most work.

Write the conventions down. Every agent that joins a task starts from whatever project instructions exist. Vague instructions produce five agents making five different reasonable guesses about your house style. This is the cheapest intervention available and the one most often skipped; our guide to Claude Code workflows goes into how to structure them.

Treat security findings as leads, not verdicts. Claude Code Security runs a multi-stage verification pass and attaches confidence scores precisely because the raw output of any scanner, AI or otherwise, contains false positives. The Firefox work is instructive here too: the standout finding was surfaced by the model in twenty minutes and then confirmed by a human in a controlled environment. That second step is not optional.

Watch the usage pool. Claude Code shares its allowance with Claude Chat and Claude Cowork. Running a five-agent team against a large repository consumes that budget quickly, and the first time most teams notice is when they hit a limit mid-task. Budget for it deliberately rather than discovering it.