What's New in Claude Code: Opus 4.6 and Agent Teams

Claude Code has shipped 35 releases since January 7, 2026. The pace is roughly one release every two days. Most of these are incremental, but three changes stand out: Opus 4.6 brought a 1M-token context window and adaptive thinking, Agent Teams turned Claude Code into a multi-agent orchestration platform, and the hooks system now supports async execution for non-blocking automation. Together, these represent the largest architectural shift since Claude Code 2.0 launched in September 2025.

Here is what actually changed, why it matters, and what I have been using in practice.

Opus 4.6: Bigger Context, Smarter Reasoning

Anthropic released Opus 4.6 on February 5, 2026, roughly three months after Opus 4.5. The model ships as part of Claude Code v2.1.32 and is available through the API, GitHub Copilot, and Microsoft Azure Foundry.

The numbers that matter:

1M token context window (beta) for Opus-class models for the first time. Long-context accuracy on the 8-needle MRCR v2 benchmark jumped from 18.5% (Sonnet 4.5) to 76%. Premium pricing applies above 200K tokens: $10/$37.50 per million input/output tokens versus the base $5/$25.

128K token output per request, up from previous limits. This means generated artifacts can be substantially longer.

Adaptive thinking: Opus 4.6 is the first Anthropic model that autonomously decides how much reasoning effort to invest in a prompt. You can also control this explicitly with the /effort parameter at four levels (low, medium, high, max).

Terminal-Bench 2.0: 65.4%, up from 59.8% for Opus 4.5. OSWorld agentic benchmark rose from 66.3% to 72.7%.

Context compaction also improved. The model automatically summarizes older context when approaching configurable thresholds, which reduces the manual /compact dance that heavy Claude Code users know well.

In my daily use, the adaptive thinking feature is the most noticeable change. Quick questions get fast answers without burning through reasoning tokens. Complex debugging sessions get deeper analysis automatically.

Agent Teams: From Single Session to Parallel Coordination

Agent Teams shipped alongside Opus 4.6 in v2.1.32 as a research preview. This is the feature that transforms Claude Code from a single-agent tool into something closer to a development team.

How it works: You enable teams with CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1. Your main Claude Code session becomes the “team lead.” It spawns teammates, each running in their own context window, and coordinates work through a shared task board.

The architecture has four components:

Component Purpose
Team lead Creates the team, assigns tasks, reviews work
Teammates Separate Claude Code instances with independent context
Task list Shared work items with status tracking and dependency resolution
Mailbox Direct and broadcast messaging between agents

Teammates communicate through SendMessage for one-to-one messages or broadcasts for team-wide alerts. Messages are delivered automatically with no polling required. The team lead can enter “delegate mode” (Shift+Tab) to restrict itself to coordination only, preventing it from implementing tasks directly.

Quality gates are the part I find most useful. Two new hook events, TeammateIdle and TaskCompleted, let you define validation rules. When a teammate marks a task complete, your hook can verify the work and reject it (exit code 2) if standards are not met. This is how you enforce code review, test coverage, or style checks across the team.

Practical use cases I have tried:

  • Parallel code review with three teammates: one checking security, one checking performance, one running tests
  • Research tasks where multiple agents explore different approaches simultaneously
  • Cross-layer work where one agent handles frontend changes while another updates the API

Current limitations: No session resumption with in-process teammates. One team per session. No nested teams. Split panes require tmux or iTerm2 and do not work in VS Code terminal, Windows Terminal, or Ghostty. Token costs are significantly higher since each teammate runs its own context window.

The Hooks System: 14 Events, 3 Types, Async Support

The hooks system has evolved from a simple pre/post tool mechanism into a full lifecycle automation layer. As of v2.1.33, Claude Code exposes 14 hook events:

SessionStart, UserPromptSubmit, PreToolUse, PermissionRequest, PostToolUse, PostToolUseFailure, Notification, SubagentStart, SubagentStop, Stop, TeammateIdle, TaskCompleted, PreCompact, and SessionEnd.

Three hook types are available:

  1. Command hooks (type: "command"): Shell scripts that receive JSON on stdin and return decisions via exit codes.
  2. Prompt hooks (type: "prompt"): Send a prompt to a fast Claude model for single-turn evaluation.
  3. Agent hooks (type: "agent"): Spawn a subagent with tool access (Read, Grep, Glob) for multi-turn verification.

Async hooks (added around January 25, 2026) are the newest addition. Setting "async": true on a command hook runs it in the background without blocking Claude’s execution. When the process finishes, output with systemMessage or additionalContext fields is delivered on the next conversation turn. Async hooks cannot block tool calls, making them ideal for logging, notifications, test suites, and deployments that should not interrupt the developer’s flow.

The hook execution timeout also increased from 60 seconds to 10 minutes (v2.1.3), which matters for hooks that run lint suites or integration tests.

Agent SDK: Building on Claude Code Programmatically

The Claude Agent SDK provides programmatic access to Claude Code’s capabilities in TypeScript and Python. The TypeScript SDK is at v0.2.34, tracking parity with Claude Code v2.1.34.

Key capabilities that have landed since January:

Structured outputs: Agents return validated JSON matching a provided schema, with Zod v3 and v4 support.

MCP server management: reconnectMcpServer(), toggleMcpServer(), and introspection via mcpServerStatus() with config, scope, and tool fields.

Tool annotations: readOnlyHint, destructiveHint, openWorldHint, idempotentHint for MCP tool metadata.

Session management: Custom session IDs and experimental v2 APIs (unstable_v2_createSession, unstable_v2_resumeSession) for multi-turn conversations.

Hook event types: TypeScript types for TeammateIdleHookInput and TaskCompletedHookInput for type-safe hook development.

1M context beta: Enable via betas: ['context-1m-2025-08-07'].

If you are building AI-assisted workflows in CI/CD pipelines or custom tooling, the SDK is the way to do it. The headless mode (claude -p) works well for non-interactive execution.

MCP: Smarter Tool Loading

MCP (Model Context Protocol) got one change that dramatically improved daily use: automatic tool deferral.

Since v2.1.7, when MCP tool descriptions would consume more than 10% of the context window, Claude Code automatically defers loading them and uses a ToolSearch mechanism to discover tools on demand. In real-world testing, this reduced total agent token usage by 46.9%, from 51K tokens down to 8.5K. The threshold is configurable with auto:N syntax.

v2.1.30 added pre-configured OAuth for MCP servers that lack Dynamic Client Registration (like Slack), reducing the friction of connecting to enterprise services. The broader MCP ecosystem now has over 500 published servers and 50,000+ developers building with the protocol.

Plugin System and Skills

Claude Code’s plugin and skill system matured through several releases:

v2.1.3: Merged slash commands and skills into a unified system. Skills are now model-invoked capabilities defined in SKILL.md files with YAML frontmatter, automatically triggered by context rather than requiring explicit slash-command activation.

v2.1.14: Plugin pinning to specific git commit SHAs for reproducible builds. Search across installed plugins.

v2.1.32: Skill character budget now scales with context window (2% of context).

v2.1.33: Plugin name appears in skill descriptions for better discoverability.

Plugins package skills, agents, hooks, MCP servers, and LSP servers into distributable units. The Agent Skills specification was released as an open standard in December 2025, and OpenAI adopted the same format for Codex CLI, creating cross-platform compatibility.

Session Memory

Claude Code v2.1.32 added automatic session memory. The system records and recalls past work without manual intervention. “Recalled X memories” appears at session start, and “Wrote X memories” appears periodically during your session.

First extraction triggers after roughly 10,000 tokens of conversation, with subsequent updates every 5,000 tokens or after every 3 tool calls. This is different from CLAUDE.md files, which you write and maintain manually. Session memory is automatic background context.

Everything Else Worth Noting

Task persistence (v2.1.16+): Tasks saved to files with status, dependencies, and broadcasts replace the old to-do system. If a session crashes, the work plan survives.

PDF page ranges (v2.1.30): The Read tool accepts a pages parameter for large PDFs.

/debug command (v2.1.30): Built-in troubleshooting for session issues.

--from-pr flag (v2.1.27): Resume sessions linked to a specific GitHub PR.

68% memory reduction for --resume via stat-based session loading (v2.1.30).

Cowork (Jan 12, 2026): Anthropic launched “Claude Code for the rest of your work,” a system-level AI agent for non-technical users that can manipulate local files and execute multi-step business processes.

Claude in Chrome: Browser automation integration that lets Claude Code interact with web applications through the Chrome extension.

GitHub integration (Feb 4, 2026): Claude and Codex available in public preview on GitHub.

What This Means

Claude Code is no longer just an AI coding assistant. With agent teams, persistent tasks, async hooks, and the SDK, it is a programmable development platform. The shift from “ask Claude a question” to “coordinate a team of agents with quality gates and dependency tracking” happened fast, compressed into about four months of releases.

The token costs for agent teams are real and add up quickly. But for tasks that benefit from parallel exploration, like debugging with competing hypotheses or reviewing code across security/performance/testing dimensions, the time savings justify the cost.

If you have not updated since January, the upgrade path is straightforward: claude update gets you to v2.1.34. Enable agent teams with the environment variable, and start with a small two-agent task to see how coordination works before scaling up.

Sources: