Anthropic dropped Opus 4.6 today. I've been running it since the early access window, and there are three things worth talking about: the 1M token context window, agent teams, and the sustained focus improvements for long-running tasks.
The rest is incremental. Good incremental, but incremental.
The 1M Context Window Changes What's Possible
Opus 4.5 had 200K tokens. That was enough for most tasks but hit a wall with large codebases, multi-document research, and long conversations that needed full history.
Opus 4.6 pushes to 1 million tokens in beta. That's roughly 750K words -- about 10 full novels, or an entire mid-size codebase loaded at once.
What this means in practice:
- Full codebase analysis without chunking or summarization hacks. Load the whole thing, ask questions, get answers that account for cross-file dependencies.
- Long research sessions where the model holds 50+ documents in context and synthesizes across all of them without losing track of source material.
- Multi-day agent sessions that don't need to be re-prompted with context every time.
The recall quality matters more than the raw number. Previous models with large context windows would degrade on information buried in the middle. Opus 4.6 maintains coherent recall across the full window -- not perfect, but noticeably better than any previous model I've tested.
Agent Teams: The Real Headline
This is the feature that matters most for anyone building with agents.
Previous models ran agents as single threads: one model instance handling an entire workflow sequentially. Complex tasks meant long chains where one mistake early on cascaded through everything.
Opus 4.6 introduces agent teams -- multiple agents that split larger tasks into segments, each owning its piece and coordinating directly with the others.
# Conceptually, this is the shift: # Before: One agent does everything agent = Agent(model="opus-4.5") result = agent.run("Research competitors, analyze pricing, draft strategy doc") # → Single thread, sequential, fragile # After: Specialized agents coordinate team = AgentTeam( researcher=Agent(role="market research"), analyst=Agent(role="pricing analysis"), writer=Agent(role="strategy documentation"), coordinator=Agent(role="task orchestration") ) result = team.run("Research competitors, analyze pricing, draft strategy doc") # → Parallel execution, each agent focused on what it's good at
The agents aren't just running in parallel -- they're communicating. The researcher passes findings to the analyst. The analyst flags inconsistencies back to the researcher. The writer gets structured input from both. The coordinator keeps everything on track.
This is the architecture pattern I've been building manually in my own multi-agent projects. Having it native to the model means less orchestration code and more reliable handoffs.
Sustained Focus on Hard Problems
The less flashy but equally important improvement: Opus 4.6 stays on task longer.
Anthropic's framing is "plans more carefully, stays on task longer, works more autonomously." In practice, this means:
- Long debugging sessions where the model doesn't lose track of what it already tried.
- Complex refactors across multiple files where it maintains consistency from file 1 through file 30.
- Multi-step research where it follows up on leads it discovered 20 steps ago.
I've been using it with Claude Code, and the difference is tangible. Tasks that previously required me to re-orient the model mid-way through now run to completion. Not always -- it still goes sideways sometimes -- but the failure rate on complex tasks dropped noticeably.
Coding Improvements
Better at code review, debugging, and operating in large codebases. The specific improvements I've noticed:
- Self-correction: Catches its own mistakes more often before I do.
- Codebase navigation: Better at finding the right file to modify without being told explicitly.
- Test generation: Writes tests that actually cover edge cases, not just happy paths.
The model ID for API usage is claude-opus-4-6. Pricing stays at $5/$25 per million tokens (input/output), same as 4.5.
The PowerPoint Thing
Anthropic also announced a research preview of Claude in PowerPoint -- it reads your existing slide layouts and templates, then generates or edits slides matching those design elements.
I don't make PowerPoint decks, so I can't evaluate this. But for agency work or enterprise environments where slide formatting is a real time sink, this could be useful.
What I'm Building With It
I'm already updating my agent infrastructure to take advantage of the longer context and agent teams:
- Blog publishing pipeline: Full vault-to-website automation where one agent handles content, another handles conversion, another handles deployment.
- Game master agent: Using agent teams for parallel world simulation -- one agent manages NPCs, another tracks game state, another generates narrative.
- Homelab orchestration: Agents that manage Docker containers, monitor services, and self-heal -- with enough context to understand the full system state at once.
What It Means
Opus 4.6 is the first model where I feel comfortable letting agents run unsupervised for extended periods. The 1M context means they don't forget. The sustained focus means they don't drift. The agent teams mean they can handle complexity that previously required custom orchestration.
Worth upgrading from 4.5? If you're building agents or working with large codebases, yes. If you're doing simple Q&A or short conversations, Sonnet is still the right tool.
The model still hallucinates. Still needs guardrails. But the ceiling for what you can build with it just went up considerably.