claude-opus-4-7

Claude Opus 4.7

The generation where Claude learned to see properly. Released 16 April 2026.

High-Resolution Images, and Coordinates That Line Up

The headline change, and the one that alters what you can build.

Maximum image resolution rose to 2576 pixels / 3.75 megapixels, up from 1568 pixels / 1.15 megapixels on earlier models. That is more than three times the pixel area — enough to read small print in a scanned document, a value on a dense chart, or a label in a screenshot that previously dissolved.

The second half matters more for anyone building an agent. Model coordinates are now 1:1 with actual pixels. Point at something in a screenshot and the coordinate it returns is the coordinate in the image, with no scale factor to apply and no conversion to get wrong.

Anthropic names the workloads this unlocks:

Computer use — where a coordinate that needs conversion is a bug waiting to happen.

Document redlining and slide editing — producing tracked changes and layouts, then visually checking its own work.

Chart and figure analysis — including pixel-level data transcription, with programmatic tool calls to image libraries doing the measurement.

That last pattern is worth noticing. The model is not estimating a value off a chart by eye; it is calling a tool to read the pixels. High resolution is what makes that possible, and 1:1 coordinates are what make it reliable.

Extended Thinking Is Gone

A breaking change from the previous generation, documented plainly.

This model accepts thinking.type: "adaptive" only. The older manual form — thinking: {"type": "enabled", "budget_tokens": N} — returns a 400 error.

Not deprecated. Not discouraged. Rejected.

If you are migrating from Opus 4.6, this is the change that stops your requests from running. Adaptive thinking with an effort level is the replacement, and it is where the family has gone since.

Specifications

The full million-token window carries no long-context premium.

Anthropic publishes no parameter counts, architecture, or weights for Claude models.

Capabilities

Raise Your Output Ceiling

Anthropic's own migration guidance is specific: update max_tokens to give additional headroom, including for compaction triggers.

Two things drive that. Adaptive thinking consumes output tokens as part of the same budget, and this model is positioned for long-horizon autonomous work where the response itself runs longer.

A ceiling carried over from a model that reasoned less will cut this one off mid-task.

What It Was Built For

Anthropic describes this model as highly autonomous, with its strongest results in long-horizon agentic work, knowledge work, vision, and memory.

Memory is a named improvement. The model is better at using file-system-based memory — keeping notes across long, multi-session work and actually consulting them rather than writing and forgetting them. For an agent that spans days rather than minutes, that is the difference between continuity and a fresh start every session.

Financial and document work benefits from the vision changes directly: dense filings, charts, tables inside PDFs. Reading them accurately was previously limited by resolution more than by comprehension.

Long-context consistency was measured as a strength on independent multi-step benchmarking, with the most consistent long-context performance in its comparison group.

Using Claude Opus 4.7 on DEVUP AI

Base URL: https://api.devupai.com/v1 · Model ID: anthropic/claude-opus-4-7

First request — cURL

curl https://api.devupai.com/v1/chat/completions \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-opus-4-7",
    "messages": [
      {
        "role": "user",
        "content": "Our nightly settlement job occasionally posts the same batch twice. It uses a file lock on a shared mount. Explain how that fails and what replaces it."
      }
    ],
    "max_tokens": 32768
  }'

Reading a dense document at full resolution — Python

Where the resolution change earns its place.

import os
import base64
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEVUP_API_KEY"],
    base_url="https://api.devupai.com/v1",
)

with open("filing_page.png", "rb") as handle:
    encoded = base64.b64encode(handle.read()).decode("utf-8")

reply = client.chat.completions.create(
    model="anthropic/claude-opus-4-7",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{encoded}"}},
                {
                    "type": "text",
                    "text": (
                        "Transcribe every figure in the footnotes, with its label. Footnote text is "
                        "small — mark anything you cannot read cleanly as unreadable rather than "
                        "reconstructing it."
                    ),
                },
            ],
        }
    ],
    max_tokens=16384,
)

print(reply.choices[0].message.content)

Send the page at full resolution. Downscaling a scan before upload throws away exactly the detail this generation was built to read — and it is the most common way a high-resolution capability goes unused.

Computer use with 1:1 coordinates — Python

with open("screen.png", "rb") as handle:
    screenshot = base64.b64encode(handle.read()).decode("utf-8")

reply = client.chat.completions.create(
    model="anthropic/claude-opus-4-7",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{screenshot}"}},
                {
                    "type": "text",
                    "text": (
                        "Locate the 'Confirm payment' button and give its centre coordinate. "
                        "If the button is not visible in this screenshot, say so."
                    ),
                },
            ],
        }
    ],
    max_tokens=1024,
)

The coordinate comes back in image pixels. On earlier models you applied a scale factor between what the model saw and what the image contained; here that step is gone, and with it a class of off-by-a-ratio bug that was tedious to find.

Asking it to report absence rather than guess is the other half. A confident coordinate for a button that is not on screen produces a click somewhere wrong.

Chart transcription with a tool — Python

The pattern Anthropic specifically highlights.

import json

IMAGE_TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "sample_pixel",
            "description": "Return the RGB value at a coordinate in the supplied image.",
            "parameters": {
                "type": "object",
                "properties": {
                    "x": {"type": "integer"},
                    "y": {"type": "integer"},
                },
                "required": ["x", "y"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "crop",
            "description": "Return a cropped region of the supplied image as a new image.",
            "parameters": {
                "type": "object",
                "properties": {
                    "left": {"type": "integer"},
                    "top": {"type": "integer"},
                    "right": {"type": "integer"},
                    "bottom": {"type": "integer"},
                },
                "required": ["left", "top", "right", "bottom"],
            },
        },
    },
]

Give the model tools that operate on pixel coordinates and it can measure rather than estimate. With 1:1 coordinates, the region it asks to crop is the region you crop — which is what makes this loop work at all.

For a chart with no printed values, this is the difference between a transcription and a guess dressed as one.

A long autonomous session — Python

TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "read_note",
            "description": "Read a persisted note from the agent's memory directory.",
            "parameters": {
                "type": "object",
                "properties": {"name": {"type": "string"}},
                "required": ["name"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "write_note",
            "description": "Persist a note for future sessions.",
            "parameters": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "content": {"type": "string"},
                },
                "required": ["name", "content"],
            },
        },
    },
]


def read_note(name: str) -> dict:
    """Replace with your real, sandboxed memory store."""
    raise NotImplementedError


def write_note(name: str, content: str) -> dict:
    """Replace with your real, sandboxed memory store."""
    raise NotImplementedError


HANDLERS = {"read_note": read_note, "write_note": write_note}

session = [
    {
        "role": "system",
        "content": (
            "You are working across multiple sessions. Read your notes before starting, and record "
            "anything a future session would need to know before finishing."
        ),
    },
    {"role": "user", "content": "Continue the reconciliation audit. Pick up where the last session left off."},
]

CEILING = 40

for step in range(CEILING):
    reply = client.chat.completions.create(
        model="anthropic/claude-opus-4-7",
        messages=session,
        tools=TOOLS,
        max_tokens=32768,  # headroom for reasoning and a long response
    )

    message = reply.choices[0].message
    session.append(message)

    if not message.tool_calls:
        print(message.content)
        break

    for call in message.tool_calls:
        handler = HANDLERS.get(call.function.name)
        if handler is None:
            outcome = {"error": "unknown tool", "name": call.function.name}
        else:
            try:
                outcome = handler(**json.loads(call.function.arguments or "{}"))
            except Exception as exc:
                # Return the failure as data so the model can adjust.
                outcome = {"error": type(exc).__name__, "detail": str(exc)}

        session.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(outcome)})
else:
    print(f"Stopped at the {CEILING}-step ceiling.")

File-system memory is a named strength here, and the system prompt above is what activates it. A model capable of reading its own notes will not do so unless told that notes exist.

CEILING ends a run that does not end itself.

Node.js — DEVUP AI SDK

npm install devupai

import DevupAI from "devupai";

const client = new DevupAI({
  apiKey: process.env.DEVUP_API_KEY,
});

const reply = await client.chat.completions.create({
  model: "anthropic/claude-opus-4-7",
  messages: [
    {
      role: "system",
      content:
        "Review this deal document. Report every figure that appears more than once with " +
        "different values, citing the page and section for each occurrence.",
    },
    { role: "user", content: documentText },
  ],
  max_tokens: 32768,
});

console.log(reply.choices[0]?.message?.content);

Streaming

stream = client.chat.completions.create(
    model="anthropic/claude-opus-4-7",
    messages=[{"role": "user", "content": "Walk through why an advisory lock is safer than a file lock for this job."}],
    max_tokens=32768,
    stream=True,
)

for chunk in stream:
    if not chunk.choices:
        if getattr(chunk, "usage", None):
            print(f"\n\nin {chunk.usage.prompt_tokens:,} · out {chunk.usage.completion_tokens:,}")
        continue

    piece = chunk.choices[0].delta
    if getattr(piece, "content", None):
        print(piece.content, end="", flush=True)

Adaptive thinking runs before visible output. Raise client timeouts before shipping a high-effort path.

Migrating

From Opus 4.6: the mandatory change is thinking.type. The manual "enabled" form with budget_tokens returns a 400 here; switch to "adaptive" and set an effort level.

Raise max_tokens as part of the same change, per Anthropic's guidance.

Re-estimate your token counts. Secondary reporting suggests the tokenizer changed in this generation, with estimates running materially higher than before — a claim worth verifying against your own usage figures rather than taking on faith, since it affects budgeting rather than correctness.

To Opus 5: thinking becomes on by default, responses may open with thinking blocks (so positional content access stops being safe), disabling thinking becomes conditional on effort, and knowledge moves four months forward. Verification instructions that help here cause over-verification there.

Choosing This Model

Reach for it when vision is the limiting factor — dense documents, charts with unprinted values, screenshot-driven agents, computer use. The resolution change is real, and it is the clearest reason to prefer this generation over the ones before it.

Also for multi-session autonomous work, where file-system memory and long-context consistency are named strengths.

Move up when knowledge more recent than January 2026 would change your answers, or when reasoning depth rather than visual fidelity is what falls short.

Limitations

Manual thinking budgets return an error. Only adaptive thinking is accepted.

Reasoning shares the output ceiling. Anthropic recommends raising max_tokens when migrating here.

Reliable knowledge stops at January 2026. Anything later needs retrieval or a search tool.

Text and images only. No audio, no video, no image generation.

A large window is not free recall. Retrieval quality still degrades as a conversation fills; the window moves the boundary rather than removing it.

Marked legacy by Anthropic, with a current model available in the same tier.

Internals are undisclosed — no parameter count, no architecture, no weights.

Reading a chart precisely is not reading it correctly. Pixel-level transcription gives you a number the model measured, not a number anyone verified. Check what matters.