Claude Opus 4.7 vs GPT-5.5 vs Gemini 3.1 Pro: Picking an LLM API in May 2026

If you've got a $500/month API budget and three flagship models to choose from, this is the question that actually matters: where does each dollar go furthest? Forget benchmark tables. The interesting answer depends on what you're building.

I've shipped production code on all three over the last six weeks. This is what I'd tell a friend.

The actual prices (per million tokens, May 2026)

* Gemini doubles its rate above 200K tokens of input. Worth knowing before you stuff a giant codebase into one call.

Pricing changes faster than this article will. Check the OpenAI and Anthropic pages on this site for current rates, or hit the provider dashboards directly.

Where Opus 4.7 earns its premium

Anthropic shipped claude-opus-4-7 on April 16, 2026. It's the model that finally made me retire the rule of thumb "use Sonnet for most things, escalate to Opus for hard ones." For coding agents, Opus 4.7 is now the floor, not the ceiling.

Specifically: if you have an agent that needs to open five files, understand how they interact, plan a refactor, and execute it without you intervening — Opus is the only model where that loop survives more than a few turns without going off the rails. Sonnet 4.6 still works for narrower tasks (single-file edits, well-scoped questions), and you should use it when you can. But the moment the task involves "figure out the architecture first," Opus is what's earning you billable hours.

The trick to making this affordable is prompt caching. A coding agent has a huge system prompt (tool definitions, repo summary, coding standards, history). That prompt is identical across calls within a session. Anthropic's cache pricing turns that bulk into effectively free reads after the first hit, as long as you stay inside the cache TTL. Without caching, you'll burn through $500 in a long afternoon.

# minimal cached system-prompt pattern
import anthropic

client = anthropic.Anthropic()
response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=4096,
    system=[
        {
            "type": "text",
            "text": LARGE_SYSTEM_PROMPT,  # 80K tokens of context
            "cache_control": {"type": "ephemeral"},
        }
    ],
    messages=[{"role": "user", "content": user_question}],
)

That cache_control block is the difference between $1 per call and 10 cents per call once warm.

Where GPT-5.5 is still the move

GPT-5.5 dropped a few weeks before Opus 4.7 and it costs $30/M output — the most expensive of the three. Most teams should not default to it. But there are two scenarios where I will pay the premium.

The first is retrieval-heavy work with structured outputs. If you're feeding the model a long, messy context and asking it to extract typed facts with stable citation, GPT-5.5 still has an edge in being deterministic about field shape and source attribution. Opus catches up under a careful prompt, but out-of-the-box GPT-5.5 needs less prompting to behave.

The second is hard math. If you've got problems that benefit from chain-of-thought numerical reasoning — derivations, proofs, anything where Wolfram-Alpha-style work is needed mid-response — GPT-5.5 is currently ahead. Not by a lot. But ahead.

For "build a chatbot," "summarize a doc," "write some marketing copy"? Don't pay GPT-5.5 prices. You're funding research, not getting product value.

Where Gemini 3.1 Pro is the only sane choice

Gemini 3.1 Pro's pricing is what makes it interesting: $2/$12 under 200K tokens, and even at $4/$18 above that, you're paying half what Opus charges. So the question is what you can get away with for half.

A lot, it turns out, if your task doesn't require deep reasoning. Bulk translation: Gemini 3.1 is the answer. Long technical doc summarization (especially in non-English): the answer. Classifying ten thousand customer support tickets: the answer. Anything where you'd be embarrassed to bill at Opus prices because the task is actually simple.

The cliff comes when the task wants the model to think. Multi-step planning, agentic tool use, code that requires architectural understanding — here Gemini still under-performs Opus by a margin you can feel. Not catastrophic, but enough that a $25/M output call from Opus saves you human review time worth way more than the price gap.

What this means for cost

The honest economics, assuming you do not just pick one model and pray:

Use Opus 4.7 where coherence and code quality matter, with caching. Reserve GPT-5.5 for the two niches above. Default Gemini 3.1 Pro for everything bulk, classification, translation, or summary-shaped.

A team I worked with last month moved from "everything on Opus" to this tiered approach and cut their monthly bill from $4,200 to $1,400 with the same product quality. The win was almost entirely Gemini eating the bulk RAG and summarization work that didn't need a frontier model.

On benchmarks

You'll find leaderboards on a dozen sites that contradict each other depending on which weighting they prefer. The signal that matters in May 2026 is which model can hold a multi-file refactor without losing the plot. Run your own real task five times. The one that doesn't waste your afternoon is the one to buy.

For most people reading this who are building anything code-shaped, that's Opus 4.7 with aggressive caching. If you're building anything else, the answer is less obvious, and the prudent path is to wire your pipeline to swap models per task and let your bill tell you what's working.