Gemini 4 Neon beats Claude Opus 5.5 on composite benchmarks (61 vs 59) at 25% lower price, but Opus 5.5 still wins long agentic coding sessions 86.9% to 79.8%.
Vamsi Tallapudi
Manager, Architect Technology at Cognizant
Google's Gemini 4 Neon launched November 18, 2026 at $3 per million input tokens and $15 per million output tokens, undercutting Claude Opus 5.5's $4/$20 pricing by 25% while posting a higher score on the Artificial Analysis Intelligence Index (61 vs 59). That's the headline everyone's running with. It's also only half the story, because the moment you move from leaderboard scores to actual coding sessions, the result flips in a way the launch coverage mostly glossed over.
I went through the official numbers, the independent Artificial Analysis comparison, the Mei Engineering Index that's been making rounds, and two separate Hacker News threads arguing about it. Here's where Neon actually wins, where Opus 5.5 still wins, and why "better on benchmarks" and "better in your terminal" turned out to be two different claims again.
Neon is Google's third Gemini 4 model in six weeks, slotting between Hydrogen (cheap, fast, everyday work) and Carbon (the long-horizon reasoning heavyweight). Google adapted it from Carbon rather than training it from scratch, and it ships with the same 1 million token context window as the rest of the Gemini 4 family, plus speech and video input that Opus 5.5 doesn't support.
Claude Opus 5.5 launched almost two months earlier, on September 22, 2026, as the first model in Anthropic's 5.5 family. Anthropic's pitch was the same shape as Google's: near-flagship performance (close to Claude Fable 5.1) at a steep discount versus Opus 5, with agentic coding runs matching Opus 5's output quality in roughly half the turns, time, and tokens.
| Model | Input (per 1M) | Output (per 1M) | Cached input | Context |
|---|---|---|---|---|
| Gemini 4 Neon | $3.00 | $15.00 | $0.15 (95% off) | 1M tokens |
| Claude Opus 5.5 | $4.00 | $20.00 | $0.20 (60% off Opus 5) | 1M tokens |
On raw token pricing, Neon is cheaper, full stop. But Artificial Analysis' per-task cost data complicates the "Neon is just cheaper" story: at low reasoning effort, Neon runs $0.75 per task against Opus 5.5's $0.98, yet at high and xhigh effort settings, Opus 5.5 is the cheaper one, even though those higher Neon tiers score better. Effort level changes which model is actually the budget pick, and most coverage skipped that part entirely.
Yes, on the composite indexes. Neon scores 61 on the Artificial Analysis Intelligence Index against Opus 5.5's 59, and 70.9% versus 70.1% on the Vals Index. It also leads the Artificial Analysis Coding Agent Index outright. Those are real numbers from a third party, not Google's own slide deck, so I'm not going to wave them away.
But "composite index" is doing a lot of work in that sentence, because the individual coding benchmarks split almost down the middle:
| Benchmark | Gemini 4 Neon | Claude Opus 5.5 | Who leads |
|---|---|---|---|
| CursorBench 4.1 | 65.4% | 58.1% | Neon, by 7.3 pts |
| Terminal-Bench 4.1 | 65.2% | 65.8% | Opus 5.5, narrowly |
| FrontierCode 2.0 | 46.2% | 47.3% | Opus 5.5, narrowly |
| Vals Vibe Code Bench | 93.7% | 90.3% | Neon |
| Vals Code Migration | 75.8% | 80.5% | Opus 5.5 |
Notice the shape of that split. Neon's biggest wins come on benchmarks measuring broad code generation and quick task completion. Opus 5.5's wins, even the narrow ones, are concentrated on terminal-driven agent work and migrating real code across versions, which is exactly the loop that Claude Code, Cursor agents, and CI-driven coding bots live in all day. That's the same pattern Gemini 4 Argon ran into last month against the same model, and it showed up again here.
This is where the picture gets less flattering for Neon. Independent agent testing from Bito ran both models through real multi-turn coding sessions rather than one-shot benchmark prompts, and the gap widened in Opus 5.5's favor: 86.9% overall against Neon's 79.8%, stretching to 89.4% versus 77.4% once sessions ran twenty turns deep.
That tracks with what I've seen pointing both models at a messy multi-file migration this week. Neon got through the easy 80% fast and cheap, then started making the kind of small, confident mistakes that are worse than an outright failure, a dropped null check here, a stale import there, because they look like finished code until you run the tests. Opus 5.5 was slower getting started (Artificial Analysis clocks its time-to-first-token at 5.4 seconds against Neon's 13.9) but held together better the longer the session ran.
Cost tells a more balanced story than the quality gap suggests, though. Neon ran that same 20-turn test for $7.37 against Opus 5.5's $18.38, roughly 60% cheaper, and finished in about 64 minutes versus 112. If your task is short and you're reviewing the output anyway, Neon's speed and price make sense. If you're letting an agent run unsupervised for twenty turns, that 7-point quality gap is the number that should decide things, not the invoice.
Mei is a newer benchmark aggregator (git-aarvin.github.io/mei) that normalizes ten coding benchmarks to an average of 50, then ranks models by cost and token efficiency alongside raw score. Neon tops it at 68.1, with Opus 5.5 down in 4th at 60.8, behind Fable 5.2 and GPT-6.2 Astra. The same table shows Opus 5.5 using roughly 2x the tokens and 3.6x the cost multiplier of a baseline model, against Neon's 0.83x tokens and 1.6x cost.
I'd treat Mei the way its own creators ask you to: directionally interesting, not gospel. The project's own disclaimer admits it's "far from perfect," and Hacker News picked the methodology apart within a day of the ranking going around, pointing out Neon only had published data for 3 of 8 underlying benchmarks against Fable's 6, with one commenter calling the ranking "clickbait" on that basis alone. An index built on uneven data coverage can still be useful for spotting a trend (Claude models do run token-heavy relative to Google's, and that shows up in actual API bills), but don't let one number stand in for a model you haven't tried on your own repo.
Both Hacker News threads covering the launch landed on a similar split, and it's worth reading past the top comment.
People who like Neon really like it, mostly for reasons that have nothing to do with benchmarks. "It writes text that is not some complete gibberish" was one reaction, and several others praised it for skipping the exclamation-point-heavy, over-eager tone that's become an AI tell in other models. One person called it "the first model I've run that criticized the amount of ceremony" in their prompts. That's a real, if fuzzy, advantage, and it's the kind of thing that benchmark tables can't capture.
But the same threads have a harder edge once the conversation turns to serious or long-running work. "Neon appears to be considerably better than Sonnet/Terra" was one comment, immediately followed by someone questioning whether Google's gains are really reasoning, or just better product polish creating the impression of intelligence. Another person doing theoretical physics work reported Neon making "doofus errors," dropped minus signs and doubled factors, that Anthropic and OpenAI's models caught and Neon didn't. And the sharpest consensus across both threads: for anything long-horizon, Opus 5.5 still wins, with one person describing it as feeling "like human level intelligent, like I'm talking to a coworker," a comparison nobody made about Neon.
Pick Neon if your workload is short tasks, high volume, or anything involving speech or video input Opus 5.5 can't touch. It's genuinely cheaper at low effort, noticeably faster to finish a session, and the prose quality is a real upgrade if you're generating anything a human reads end to end, docs, commit messages, PR descriptions.
Stick with Opus 5.5 if you're running agentic coding loops longer than a handful of turns, migrating real code across versions, or doing anything in Claude Code, Cursor, or a CI pipeline where a confidently wrong diff costs you more than the extra tokens did. The terminal and migration benchmarks plus the 20-turn agent testing all point the same direction, and that's not a coincidence. Anthropic has spent five Opus generations tuning exactly that loop, and it shows every time the task gets long enough to matter.
If you're price-sensitive and your tasks are genuinely short, Neon's discount is real and I wouldn't talk anyone out of trying it. Just don't assume a 61 beats a 59 on an aggregate index means it'll beat Opus 5.5 on the specific repo you're about to hand it. Run both on your actual work before you re-point a production agent stack over a leaderboard screenshot.
Gemini 4 Neon costs $3 per million input tokens and $15 per million output tokens, versus $4 and $20 for Claude Opus 5.5, a 25% gap on raw token price. Per-task cost flips depending on reasoning effort: Neon is cheaper at low effort, Opus 5.5 is cheaper at high and xhigh effort.
On composite indexes, yes: 61 vs 59 on the Artificial Analysis Intelligence Index and a lead on the Coding Agent Index. On individual coding benchmarks it's split, Neon leads CursorBench 4.1 and Vibe Code Bench, Opus 5.5 leads Terminal-Bench 4.1, FrontierCode 2.0, and Code Migration.
Independent multi-turn testing favors Opus 5.5, scoring 86.9% overall against Neon's 79.8%, a gap that widens to 89.4% vs 77.4% on 20-turn sessions. Neon finishes faster and roughly 60% cheaper per session, so the choice depends on whether quality or cost matters more for your workload.
Mei is a third-party aggregator that normalizes ten coding benchmarks to rank models by score, cost, and token efficiency. Gemini 4 Neon ranks #1 at 68.1, Claude Opus 5.5 ranks #4 at 60.8. The project itself warns the index is imperfect, and Hacker News critics noted uneven benchmark coverage between models in the ranking.
Usually, especially for short, high-volume tasks. Bito's agent testing found Neon costs about 60% less per coding session ($7.37 vs $18.38), but that session also scored meaningfully lower on quality, so cheaper isn't automatically better once you factor in rework.
Not based on benchmarks alone. The terminal-agent and code-migration benchmarks, plus independent long-session testing, all favor Opus 5.5 for exactly the kind of looped, multi-step work Claude Code and Cursor agents do. Neon is worth testing for shorter, cheaper, or multimodal tasks, but a blanket swap isn't supported by the data yet.
For more on this release cycle, see our breakdowns of Gemini 4 Neon's launch pricing and benchmarks, Gemini 4 Argon vs Claude Opus 5.5, and Claude Opus 5.5 review and pricing. For the model it's adapted from, read Gemini 4 Carbon explained.
New AI tools, automation workflows, and course drops — straight to your inbox. Join 2,400+ builders.
Claude Fable 5.2 agents ran unsupervised for six weeks and solved two open black hole physics problems, including a calculation stuck since 2003. Here's how the setup actually worked.
CVE-2026-123007 is a CVSS 9.2 nginx HTTP/2 flaw going back to 2015. Here's how to check if you're exposed and patch to 1.31.9 or 1.30.7 today.
Claude Code, Codex CLI, Pi, and OpenCode each win on different models. Runta's eval found harness choice swinging cost up to 4.4x on the same model.
Comments