Back to Lab

Claude Opus 4.7 Is Here: Everything That Changed

Anthropic just shipped Claude Opus 4.7. Not a preview or a waitlist. It's live in the Claude app right now and rolling out across the API, Amazon Bedrock, Google Vertex AI, and Microsoft Foundry.

I've been running it for the last hour. Here's everything that changed, what breaks, and what you need to do about it today.

3x Vision Resolution

The vision upgrade is the one you'll feel immediately. Opus 4.7 accepts images up to 2,576 pixels on the long edge (roughly 3.75 megapixels). Previous Claude models maxed out at 1,568 pixels and 1.15 megapixels. That's a 3x jump.

If you're building with computer use, screenshot analysis, or document understanding, this changes what the model can actually see. Small text in UI screenshots, fine details in charts, dense tables in scanned documents. All of that was lossy before. Now the model gets the full picture.

There's also a solid quality-of-life fix: coordinate mapping is now 1:1 with actual pixels. No more scale-factor math when mapping bounding boxes or click targets. The model's coordinates match the image directly.

The tradeoff is token cost. Higher resolution images eat more tokens. If you're sending images where the extra detail doesn't matter, downsample before sending to keep costs flat.

New xhigh Effort Level

The effort parameter now has five levels instead of four. The new `xhigh` sits between `high` and `max`, giving you finer control over the intelligence-vs-speed tradeoff.

Anthropic recommends starting with `xhigh` for coding and agentic workloads. For anything where accuracy matters more than speed, use at least `high`. Lower effort levels make the model more literal and less exploratory, which works for structured tasks but gets risky on open-ended problems.

This only applies to the Messages API. If you're using Claude Managed Agents, effort is handled automatically.

Task Budgets (Beta)

If you're building agents, pay attention here. Task budgets give Claude an advisory token ceiling for an entire agentic loop, not just a single response.

You set a total token count. The model sees a running countdown as it works and uses it to prioritize tasks, skip low-value work, and wrap up gracefully before the budget runs out.

response = client.beta.messages.create(
    model="claude-opus-4-7",
    max_tokens=128000,
    output_config={
        "effort": "high",
        "task_budget": {"type": "tokens", "total": 128000},
    },
    messages=[...],
    betas=["task-budgets-2026-03-13"],
)

Key details: minimum budget is 20,000 tokens. This is advisory, not a hard cap. The model is aware of task budgets (unlike `max_tokens`, which it can't see). For open-ended tasks where quality matters more than cost, skip the budget entirely. For production pipelines where you need predictable token spend, this fills a real gap.

Breaking Changes (Read This First)

Three things will break existing Opus 4.6 code if you switch to 4.7 without updating.

Extended thinking budgets are gone. If your code sets `thinking: {"type": "enabled", "budget_tokens": N}`, you'll get a 400 error. Adaptive thinking is now the only supported thinking mode. And here's the critical detail: adaptive thinking is OFF by default. If you were relying on extended thinking and switch to 4.7 without updating your config, the model won't think at all.

Migration:

# Before (Opus 4.6)
thinking = {"type": "enabled", "budget_tokens": 32000}

# After (Opus 4.7)
thinking = {"type": "adaptive"}
output_config = {"effort": "high"}

Sampling parameters removed. Setting `temperature`, `top_p`, or `top_k` to any non-default value returns a 400 error. Not deprecated. Removed. The safest fix is to delete these parameters entirely and use prompting to control output style. If you were using `temperature=0` for deterministic output, it never actually guaranteed identical responses anyway.

Thinking content hidden by default. Thinking blocks still exist in the response stream, but their content is empty unless you opt in. If your product streams reasoning to users, this shows up as a long pause before output starts. One-line fix:

thinking = {
    "type": "adaptive",
    "display": "summarized",
}

The Tokenizer Change

Opus 4.7 uses a new tokenizer. Same text, more tokens. Roughly 1x to 1.35x increase depending on content type. That means the same prompt can cost up to 35% more tokens through the new model.

Update your `max_tokens` parameters to add headroom. Update compaction triggers if you have them. The 1M context window stays and there's no long-context pricing premium, but your existing token math is wrong if you don't account for this.

Use the `/v1/messages/count_tokens` endpoint to get accurate counts for 4.7.

Behavior Changes (Not Breaking, But Noticeable)

These won't crash your code but will change how the model responds:

More literal instruction following. Opus 4.7 does exactly what you ask and nothing more, especially at lower effort levels. It won't silently generalize from one example to another, and it won't infer requests you didn't make. If your prompts relied on the model reading between the lines, you'll need to be more explicit.

Responses scale to task complexity. Instead of defaulting to a fixed verbosity, the model matches its response length to how complex the task actually is. Simple question, short answer. Complex analysis, detailed response.

Fewer tool calls. The model reasons more and calls tools less by default. If your workflow depends on heavy tool use, raise the effort level.

More direct tone. Less validation language, fewer emojis, more opinionated responses. If you built prompts to counteract Opus 4.6's warmth, you can probably strip that scaffolding.

Fewer subagents. If you're building multi-agent systems, Opus 4.7 spawns fewer helper agents by default. You can steer this through prompting if you want more parallelism.

Cybersecurity safeguards. The model now actively screens for prohibited security requests. Legitimate security researchers can apply to Anthropic's Cyber Verification Program for expanded access.

Better Memory, Better Knowledge Work

Two improvements that are hard to benchmark but easy to notice in practice.

Opus 4.7 is noticeably better at maintaining and using file-system-based memory. If you have agents that write scratchpads, keep notes, or track state across turns, they should get smarter about what they write down and how they use it later. I run a file-based memory system in Claude Code daily, so this one matters to me personally.

For knowledge work, the model handles .docx redlining and .pptx editing more reliably, and it's better at programmatic chart analysis, including pixel-level data extraction from images. If your existing prompts included workarounds for these limitations ("double-check the layout before returning"), try removing them and re-testing.

Pricing and Availability

No price change. Still 5 USD per million input tokens, 25 USD per million output tokens. Available through the Claude app, the API, Amazon Bedrock, Google Cloud Vertex AI, and Microsoft Foundry. Model ID: `claude-opus-4-7`.

Migration Checklist

If you're moving from Opus 4.6 to 4.7, here's the short list:

1. Replace `thinking: {"type": "enabled", "budget_tokens": N}` with `thinking: {"type": "adaptive"}` and pair it with `output_config: {"effort": "high"}`.

2. Remove all `temperature`, `top_p`, and `top_k` parameters from your API calls.

3. Add `"display": "summarized"` to your thinking config if you stream reasoning to users.

4. Increase `max_tokens` by at least 35% to account for the new tokenizer.

5. Update compaction triggers and any token-counting logic.

6. Test prompts for literal interpretation. Add explicit instructions where you previously relied on the model inferring intent.

7. Remove any scaffolding you added to force progress updates or workaround vision limitations.

8. If you use computer use or screenshot workflows, test with the new 1:1 coordinate mapping and remove any scale-factor corrections.

Anthropic published a full migration guide in their docs. If you use Claude Code or the Agent SDK, the built-in Claude API skill can apply these migration steps to your codebase automatically.

What I Am Watching

Opus 4.7 is the incremental update. The leaked source code from last month revealed Mythos, a next-generation model that Anthropic called "the most capable model we have built to date." That model is currently restricted to security research partners. Opus 4.7's cybersecurity safeguards are explicitly described as "testing ground" for Mythos capabilities. The runway to broader Mythos access just got shorter.

There's also an AI design tool that generates websites and presentations from prompts, plus a Figma partnership for converting AI-generated code into editable design files. Whether those ship alongside 4.7 or in a separate launch isn't clear yet.

The model that leaked is now the model that shipped. And the model that hasn't shipped yet is the one worth watching.

Back to all articles