Gemini 4 Neon vs Claude Opus 5.5 vs GPT-6.2 Sol: What the Benchmarks Actually Show
Google's Neon vs Opus 5.5 vs GPT-6.2 Sol table with every harness label, plus independent cost, speed and hallucination data, official prices, access and task picks.
On Google’s own 19-row table, Gemini 4 Neon leads 16 rows, Claude Opus 5.5 leads two (Terminal-Bench 4.1 and FrontierCode 2.0) and GPT-6.2 Sol leads one (Chartography). Independent Artificial Analysis data agrees that Neon has the highest Intelligence Index of the three (61 vs 59 vs 57) and by far the lowest hallucination rate. It also shows something the vendor table leaves out: Sol completed the same index tasks for about $1.01 and 8.5 minutes each, against $6.44 and 21.5 minutes for Neon and $10.04 and 24.5 minutes for Opus. Neon is the stronger generalist on paper. Opus keeps a narrow edge on Google’s Terminal-Bench 4.1 and FrontierCode 2.0 rows, though AA’s own Terminal-Bench 4.0 run puts it last of the three. Sol is the cheap, fast option that gives up a few points almost everywhere.
What this article adds:
- Google’s comparison table rebuilt with the harness, thinking level and data source for each row, taken from Google’s evaluation methodology PDF
- Artificial Analysis numbers fetched live on November 19, 2026, covering index, cost per task, time per task and hallucination
- official per-token prices from Google, Anthropic and OpenAI
- an exact statement of where each model can be called today
- a small Ofox run of Opus 5.5 and Sol on three coding tasks
Ofox publishes this article and resells Opus 5.5 and Sol. It does not offer Neon. The benchmark rows are other parties’ results, not ours. The only results we measured are in the section on our run, and that run is illustrative only. It does not rank the models.
Google’s comparison table, with every label kept
Google’s Gemini 4 Neon model card (published November 18, 2026) is the only official source that puts these three models side by side. The methodology PDF matters as much as the scores. It says Neon was run “with the highest thinking settings unless indicated otherwise,” which means xhigh. For Opus 5.5 and GPT-6.2 Sol, Google reports the maximum reasoning setting available, or the best available result where no maximum is published. Unless a row says otherwise, competitor numbers are self-reported by Anthropic and OpenAI. Google did not run them.
| Category | Benchmark (setting) | Neon | Opus 5.5 | GPT-6.2 Sol | Row leader | Who produced the numbers |
|---|---|---|---|---|---|---|
| Index | AA Index v5.0.1 | 61 | 59 | 57 | Neon | Artificial Analysis |
| Index | Vals Index v2.2 | 70.9% | 70.1% | 66.1% | Neon | Vals AI |
| Agentic coding | CursorBench 4.1 | 65.4% | 58.1% | — | Neon | Cursor |
| Agentic coding | Terminal-Bench 4.1, cheating-adjusted accuracy | 65.2% | 65.8% | 61.5% | Opus | Neon: Artificial Analysis with Antigravity-CLI 1.5.9; others: public leaderboard |
| Agentic coding | FrontierCode 2.0, main score | 46.2% | 47.3% | 43.8% | Opus | Public leaderboard; Neon at high, not xhigh |
| Agentic coding | SWE-sweep, provider harness | 39.0% | 10.1% | 8.3% | Neon | Google self-computed: Antigravity-CLI 1.5.9 / Claude Code / Codex |
| Agentic coding | SWE-sweep, Mini-SWE harness | 12.8% | 3.6% | 11.6% | Neon | Google self-computed, mini-swe-agent vision harness |
| Knowledge work | AutomationBench | 56.3% | 42.5% | 41.3% | Neon | Public leaderboard |
| Knowledge work | Agents’ Last Exam v1.1 | 75.8% | 71.6% | 73.0% | Neon | Neon: Google, Antigravity-CLI 1.4.8, 5-hour window; Sol: OpenAI system card; Opus: leaderboard |
| Science and math | RiemannBench | 84.0% | 80.0% | 80.0% | Neon | Public leaderboard |
| Science and math | Terminal-Bench-Science 0.1 | 70.5% | 63.3% | 68.0% | Neon | Neon: Google, mini-swe-agent vision harness, average of 5 attempts; others: leaderboard |
| Reasoning | HLE-Diamond | 71.3% | 67.9% | 64.0% | Neon | Artificial Analysis |
| Multimodal | MKA, Climb WSR | 56.5% | 53.0% | 52.7% | Neon | Artificial Analysis |
| Multimodal | Chartography | 73.5% | 66.3% | 75.1% | Sol | Neon and Sol: Google, no tools; Opus: Anthropic system card |
| Multimodal | LVBench | 89.0% | 83.7% | 87.6% | Neon | Google; different frame budgets per model |
| Long context | GraphWalks, 256k–1M BFS (F1) | 95.2% | 66.8% | 80.1% | Neon | Google self-computed, 200 problems |
| Cybersecurity | CWE-Bench v2 | 70.7% | 67.1% | 66.0% | Neon | Public leaderboard (Collinear) |
| Cybersecurity | SEC-bench Pro | 90.5% | — | 88.3% | Neon | Neon: Google, Antigravity harness; Sol: OpenAI report |
| Cybersecurity | WebExploitBench v1.2 | 51.3% | 37.1% | — | Neon | Google self-evaluated, validated by AgentCyberRange |
Sources: Neon model card and evaluation methodology, both checked November 19, 2026. A dash means Google published no number for that model. A dash is not a zero.
Where Neon’s lead is real and where it is thin
Several rows are close enough that a different run could reverse them. Neon leads Opus on the Vals Index by 0.8 points and Sol on Agents’ Last Exam by 2.8 points. It trails Opus on Terminal-Bench 4.1 by only 0.6 points. Gaps under about two points on agentic benchmarks are within the range that harness versions, retries and timeouts can move. Treat these rows as ties for planning purposes.
Neon’s largest leads are on GraphWalks (95.2% vs 80.1% for Sol and 66.8% for Opus), AutomationBench (about 14 points), CursorBench (7.3 points over Opus) and the provider-harness SWE-sweep row. That last row needs the most care.
Why the SWE-sweep 39.0% is mostly a harness result
Google ran SWE-sweep twice. In the provider harness row, each model used its vendor’s agent: Antigravity-CLI for Neon, Claude Code for Opus and Codex for Sol. Google’s methodology notes that the public Antigravity-CLI includes a default sub-agent tool that fans out across the codebase, which it calls “particularly suited to bug finding tasks like SWE-sweep.”
Neon scores 39.0% in that setting and 12.8% in the shared Mini-SWE harness. Opus falls from 10.1% in Claude Code to 3.6%. Sol moves the other way: 8.3% in Codex and 11.6% in Mini-SWE. The announcement itself says Neon “more than triples” in Antigravity. So the 39.0% measures Neon running inside Google’s agent product. It does not show that the model is three to four times stronger than its rivals. On the like-for-like Mini-SWE row, Neon leads Sol by 1.2 points.
Two more labels change how rows read. FrontierCode was scored with Neon at its default high level, not xhigh. Terminal-Bench is reported as cheating-adjusted accuracy for all three models; the methodology does not define the adjustment further. Google’s announcement reports Neon at 0.0% cheating on Terminal-Bench 4.0. The LVBench row also gave the models different inputs: 1 frame per second at low resolution for Gemini, 500 frames for Sol and 600 for Opus, each set “due to API limitations.”
Why vendor tables need caution in general
- The vendor chose the comparison set. Google compared Neon with Opus 5.5 and GPT-6.2 Sol. It left out Claude Fable 5.2 and GPT-6.2 Astra, which cost $8/$40 per million tokens and score higher on the Artificial Analysis Intelligence Index (64.6 and 62.1 at max on November 19). The table shows where Neon stands against its price peers. It does not show where Neon stands at the top.
- Mixed sources share one column. Some cells are Google’s own runs and others are copied from competitors’ system cards, which used different hardware, prompts and dates.
- Settings are not uniform. Neon was run at
xhighon most rows, the competitors at their maximum setting where one was reported, and Neon athighon FrontierCode. - Benchmarks were picked after training. A launch table shows the benchmarks a vendor chose to publish, so it cannot show the benchmarks it left out.
None of this makes the table wrong. It means you should use it to decide what to test, not as the final answer.
What independent data adds: cost, time and hallucination
Artificial Analysis (AA) runs every model through the same harness and publishes cost and time per task, which the model card does not show. We read the Neon, Opus 5.5 and GPT-6.2 Sol pages and the AA-Omniscience evaluation on November 19, 2026, around 03:20 UTC. AA updates these pages, so recheck them before you make a decision.
| AA metric (top reasoning variant) | Neon (xhigh) | Opus 5.5 (max) | GPT-6.2 Sol (max) |
|---|---|---|---|
| Intelligence Index v5.0.1 | 61.4 | 59.1 | 57.3 |
| Cost per Intelligence Index task | $6.44 | $10.04 | $1.01 |
| Time per task | 21.5 min | 24.5 min | 8.5 min |
| Output tokens per task (reasoning + answer) | ~142k | ~173k | ~40k |
| Time to first answer token | 56.5 s | 335.8 s | 75.1 s |
| Terminal-Bench 4.0 (AA run) | 63.6% | 59.6% | 60.1% |
| FrontierCode 2.0 (AA run) | 44.4% | 46.4% | 44.4% |
| AA-Omniscience accuracy | 60.5% | 65.5% | 61.6% |
| AA-Omniscience hallucination rate | 14.4% | 50.3% | 55.4% |
| AA-Omniscience attempt rate | 67.5% | 86.7% | 85.4% |
| HLE-Diamond | 71.3% | 67.9% | 64.0% |
These are three different settings: xhigh for Neon and max for the other two. Lower settings score lower and cost less. For Neon at its default high, AA’s data gives an index of 59.6, $3.74 and 14.8 minutes per task, and a 13.9% hallucination rate. That is still above Sol at max on the index and still more than three times Sol’s cost per task. AA lists Opus at 57.4 at xhigh ($6.05 and 16.1 min per task) and Sol at 54.9 at high ($0.56 and 4.6 min). Anthropic documents medium as Opus 5.5’s default effort; at medium, AA gives Opus an index of 48.2 and $2.45 per task.
Three findings stand out:
- The list-price ratio understates the gap in cost per task. Opus has twice Sol’s list price per token, but it cost about ten times more per AA task. It produced roughly four times as many output tokens. Neon costs 1.5 times Sol’s list price and about 6.4 times more per task. The number of tokens a model spends matters more than its rate card.
- A low hallucination rate does not mean higher accuracy. AA defines hallucination rate as incorrect answers divided by all non-correct responses. Neon is lowest (14.4%) mainly because it declines to answer more often: it attempted 67.5% of questions, against about 86% for the others. Opus has the highest accuracy (65.5%) but guesses when it does not know. If a wrong answer costs you more than “I don’t know”, Neon has the better profile. If coverage matters more, Opus answers more questions correctly.
- Sol’s speed advantage is large. Its time per task is less than half of the other two, and it reached its first answer token much sooner than Opus at max effort, which took 336 seconds.
AA’s own coding runs complicate Google’s coding story in both directions. On AA’s FrontierCode 2.0 run, Opus leads at 46.4%, with Neon and Sol both at 44.4%, so Opus is first there as in Google’s table. On AA’s Terminal-Bench 4.0 run, Neon leads at 63.6% and Opus is last at 59.6%, behind Sol’s 60.1%. That is the opposite of Google’s Terminal-Bench 4.1 row, so Opus’ terminal edge depends on which benchmark version and harness you look at. Google’s announcement also says Neon ranks #1 overall on the AA Coding Agent Index with 58.6. That is Google’s claim. The AA pages we read did not expose per-model Coding Agent Index values, so we have not verified it.
Official prices per token
All rates are Standard tier, USD per 1 million tokens, checked November 19, 2026. These are the providers’ own prices. Ofox prices are shown on each Ofox model page and are not repeated here.
| Gemini 4 Neon | Claude Opus 5.5 | GPT-6.2 Sol | |
|---|---|---|---|
| Input | $3.00 | $4.00 | $2.00 |
| Output (thinking included) | $15.00 | $20.00 | $10.00 |
| Cached input | $0.15 (implicit caching only) | $0.20 cache hit | $0.10 |
| Cache writes | Not listed separately | $5 (5 min), $8 (1 h) | $2.50 (30 min), $5 (12 h) |
| Very long prompts | One rate across the 1M window | Standard rate across the full 1M window | Over 272K input: input and cache rates ×2, output ×1.5 |
| Batch | $1.50 / $7.50 (Flex is the same) | 50% off: $2 / $10 | 50% off: $1 / $5 |
| Free tier | None | — | — |
| Source | Gemini API pricing | Anthropic pricing | GPT-6.2 Sol model page |
A quick calculation shows why the per-token rate alone is not enough. Take one uncached request of 50,000 input and 10,000 output tokens. At list price that costs $0.30 on Neon, $0.40 on Opus and $0.20 on Sol. But the same text does not produce the same token count on each model. In our run below, the identical prompt used 139 input tokens on Opus and 98 on Sol. Models also differ in how much they write. Measure your own token counts per model before you compare bills. The Claude Opus 5.5 pricing guide and our Gemini 4 Neon pricing breakdown cover caching and thinking levels in more depth.
Neon’s $3/$15 rate also matters inside the Gemini family. Carbon and Argon rise from $2/$10 to $4/$20 on December 1, 2026, after which Neon is cheaper than both. See what the December change means and Neon vs Carbon.
Where you can actually use each model
| Gemini 4 Neon | Claude Opus 5.5 | GPT-6.2 Sol | |
|---|---|---|---|
| API model ID | gemini-4-neon | claude-opus-5-5 | gpt-6.2-sol |
| API status | Gemini API paid tier, through generateContent and the Interactions API | Claude API, Bedrock, Google Cloud, Microsoft Foundry | OpenAI API since Nov 17, 2026; Responses API and Chat Completions |
| Consumer and IDE access | Gemini app (AI Pro and Ultra), AI Studio, Google Antigravity (paid Pro and Ultra), Gemini for business | Claude apps and Claude Code (access and limits) | Preview in ChatGPT Work and Codex desktop (Plus and Pro; managed workspaces depend on seat settings); not in regular Chat |
| On Ofox (checked Nov 19, 2026) | No | Yes: anthropic/claude-opus-5.5 | Yes: openai/gpt-6.2-sol |
| Context window | 1,048,576 tokens, input and output combined | 1M | 1,050,000 (922K max input) |
| Max output | 64K synchronous by default; up to 1M with long decode | 128K (300K on Batch with a beta header) | 128K |
| Inputs | Text, image, audio, video | Text, image | Text, image |
| Knowledge cutoff | March 2026 | June 2026 (reliable) | June 1, 2026 |
What the GPT-6.2 Sol “preview” label means. OpenAI’s ChatGPT release notes for November 17, 2026 say that GPT-6.2 Astra and Sol are “available in preview in Work and Codex desktop” and that “Regular Chat keeps its existing model choices.” That label applies to ChatGPT. On the developer side, the OpenAI API changelog lists gpt-6.2-sol as released on November 17 for the Responses API and Chat Completions. The model page publishes prices and rate limits for usage tiers from Build to Grow, and none of these carries a preview label. In practice:
- You can build on the API now.
- Tool calling requires the Responses API.
- The API rejects
reasoning.effort: none. - If you use ChatGPT, you only see Sol in the Work and Codex model pickers.
If you are coming from GPT-6 Sol, the Responses tool-calling migration notes still apply.
Neon on Ofox. On November 19, 2026, google/gemini-4-neon was missing from GET https://api.ofox.io/v1/models, and https://ofox.io/models/google/gemini-4-neon returned 404. To use Neon, call Google directly. The Neon API guide covers setup. On Ofox you can use Gemini 4 Hydrogen and Argon today through the Gemini-native endpoint.
Our small run: Opus 5.5 vs Sol on three coding tasks
This section is the only part of the article we measured ourselves. It is illustrative. Three easy tasks with two runs each cannot rank two frontier models, and both models passed every test. We include it because it shows the verbosity and latency difference that AA’s cost data suggests, at a scale anyone can reproduce.
Setup (November 19, 2026):
- Endpoint: Ofox
https://api.ofox.io/v1/chat/completions - Models:
anthropic/claude-opus-5.5andopenai/gpt-6.2-sol - Parameters:
max_tokens: 16000. No reasoning or effort parameter was sent, so each model ran at its route default.
Tasks:
- T1: fix an off-by-one pagination bug and add input validation
- T2: write
parse_duration("1h30m")from a strict specification with nine invalid inputs - T3: implement a
TokenBucketwith an injectable clock
Each answer was graded by hidden unit tests run locally: 5, 16 and 5 test cases. There were 12 calls in total, with two repetitions per task and model.
| Task | Tests passed (both reps) | Opus 5.5 latency | Sol latency | Opus output tokens | Sol output tokens |
|---|---|---|---|---|---|
| T1 pagination fix | 5/5 and 5/5 for both | 3.4 / 3.9 s | 3.5 / 3.1 s | 142 / 142 | 184 / 181 |
| T2 duration parser | 16/16 for both | 6.2 / 5.9 s | 2.5 / 2.4 s | 471 / 438 | 119 / 117 |
| T3 token bucket | 5/5 for both | 9.0 / 8.6 s | 2.7 / 3.6 s | 656 / 756 | 253 / 268 |
Totals: Opus used 1,136 input and 2,605 output tokens, and Sol used 804 input and 1,122 output tokens. At the providers’ list prices, that is about $0.057 for Opus and $0.013 for Sol for all six calls each. That figure is our calculation, not an Ofox invoice. Median latency was 6.0 seconds for Opus and 2.9 seconds for Sol.
What we observed, beyond pass and fail:
- Opus went beyond the specification on T3. In both runs it added a
threading.Lock, acapacityproperty and a check thatclockis callable. None of these was requested. A lock is a reasonable production choice, but it is extra scope to review. Sol delivered exactly the requested interface. - On the easy bug fix (T1), Sol wrote slightly more. It added an explicit
start >= len(items)early return that slicing already handles. The difference was small in both directions. - The same prompt produced different input token counts. Opus counted 139 to 234 input tokens and Sol 98 to 153, about 40% more on Opus. This affects per-token comparisons on long prompts.
What this run does not show: anything about Neon, which is not on Ofox; hard multi-file work, where Opus’ benchmark edge would matter; or reliability across many runs. The scripts, prompts, tests and raw responses (key redacted) are kept with our report so the run can be repeated. To run your own comparison through Ofox, the integrations docs cover Claude Code, Codex, Cursor and other clients.
Calling the three models
Opus 5.5 and Sol go through one OpenAI-compatible client on Ofox. The Opus 5.5 model page lists both openai and anthropic protocols. Sol lists openai.
from openai import OpenAI
import os, time
client = OpenAI(base_url="https://api.ofox.io/v1", api_key=os.environ["OFOX_API_KEY"])
for model in ["anthropic/claude-opus-5.5", "openai/gpt-6.2-sol"]:
t = time.time()
r = client.chat.completions.create(
model=model,
messages=[{"role": "user", "content": "Write parse_duration('1h30m') -> 5400 in Python. Code only."}],
max_tokens=16000,
)
print(model, round(time.time() - t, 1), "s", r.usage)
Neon goes through Google’s native API. This example follows Google’s Neon guide:
from google import genai
client = genai.Client() # reads GEMINI_API_KEY; Neon needs the paid tier
interaction = client.interactions.create(
model="gemini-4-neon",
input="Write parse_duration('1h30m') -> 5400 in Python. Code only.",
)
print(interaction.output_text)
Common failures:
- Model not found. On Ofox, use the full ID including the vendor prefix. On OpenAI, check that your account and SDK see
gpt-6.2-sol. See model-not-found troubleshooting. - 429 or 529. Long agent runs with Opus at high effort hit rate and overload limits more often. Back off as described in the 429 retry guide and the Claude 529 fix. Ofox’s own limits are described in the rate limits doc, and response codes in the error handling guide.
- Neon 4xx on the free tier. Neon has no free tier. Errors on other Gemini 4 models are covered in Gemini 4 Argon API errors, and many apply to Neon too.
Which model for which task
These are evidence-based starting points, not measured rankings. Each line says which evidence it relies on.
| Your task | Start with | Why | Evidence |
|---|---|---|---|
| Hard multi-file software work where a few points matter | Opus 5.5, but test Neon too | Leads FrontierCode 2.0 in Google’s table and AA’s run. Leads Terminal-Bench 4.1 in Google’s table but is last on AA’s Terminal-Bench 4.0 | Google table and AA (mixed) |
| Bug hunting across a large repo inside Google’s tooling | Neon in Antigravity | 39.0% SWE-sweep with Google’s sub-agent harness; the edge mostly disappears in Mini-SWE | Google table (harness-dependent) |
| High-volume coding agents, CI fixes, everyday PRs | Sol | About 1/6 of Neon’s and 1/10 of Opus’ AA cost per task and under half the time, at 57 on AA’s Intelligence Index vs 59 and 61 | AA and our small run |
| Long-context analysis (256K to 1M tokens) | Neon | GraphWalks 95.2% vs 80.1% and 66.8%. Sol’s price rises above 272K input | Google table (self-computed) and price pages |
| Research or knowledge work where wrong answers are costly | Neon | 14.4% hallucination rate vs 50% and more; expect more abstentions | AA-Omniscience |
| Knowledge Q&A where coverage matters most | Opus 5.5 | Highest AA-Omniscience accuracy at 65.5% | AA-Omniscience |
| Chart and dense-figure reading | Sol or Neon | Sol leads Chartography, 75.1% vs 73.5%; Opus is at 66.3% | Google table |
| Audio or video inputs | Neon | The only one of the three that accepts audio and video | Official model docs |
| Business workflow automation | Neon | AutomationBench 56.3% vs about 42% | Public leaderboard via Google |
| You need one gateway and one key | Opus 5.5 or Sol | Both are on Ofox; Neon is not | Ofox model list, Nov 19, 2026 |
What each model is worse at
Gemini 4 Neon
- Narrowly behind Opus on Terminal-Bench 4.1 and FrontierCode 2.0 in Google’s table, and on FrontierCode in AA’s run.
- Lower AA-Omniscience accuracy than Opus, because it declines more questions.
- Its headline SWE-sweep score depends on Google’s harness.
- At
xhigh, a task takes about 21 minutes and costs about $6.44 on AA’s workload. - It has the oldest knowledge cutoff of the three (March 2026).
- There is no free tier, and it is not available on Ofox.
Claude Opus 5.5
- The most expensive and slowest per AA task at max effort ($10.04, 24.5 minutes, 336 seconds to first answer token).
- Last of the three on AA’s Terminal-Bench 4.0 run (59.6%), despite leading Google’s Terminal-Bench 4.1 row.
- Weakest of the three on GraphWalks long context (66.8%), Chartography (66.3%) and Mini-SWE SWE-sweep (3.6%).
- Its hallucination rate is about 50%.
- No audio or video input.
- In our small run, it added scope that was not requested.
GPT-6.2 Sol
- Lowest AA Intelligence Index of the three (57).
- Highest hallucination rate (55.4%).
- Last of the three in Google’s table on Terminal-Bench 4.1, FrontierCode, Vals and HLE-Diamond.
- Input above 272K tokens is billed at higher rates.
- Google published no CursorBench or WebExploitBench number for it.
- In ChatGPT it is still a preview limited to Work and Codex.
Use Google’s table to choose which model to test first, and Artificial Analysis for cost, speed and hallucination. Your own pass rate on your own tasks should make the final decision. For the model tiers above and below these three, see Gemini 4 model selection, the earlier GPT-6 Sol vs Claude Opus 5.5 coding cost comparison and Claude Opus 5.5 vs GPT-6 Astra for complex coding.
Related Docs
Frequently Asked Questions
- Is GPT-6.2 Sol only a preview?
- Only in ChatGPT. OpenAI's ChatGPT release notes of November 17, 2026 say GPT-6.2 Astra and Sol are available in preview in ChatGPT Work and Codex desktop, and that regular Chat keeps its existing models. The OpenAI API changelog lists gpt-6.2-sol as released the same day for the Responses API and Chat Completions, with published pricing and rate limits and no preview label.
- Can I call Gemini 4 Neon through Ofox?
- Not as of November 19, 2026. google/gemini-4-neon is not in the Ofox model list and has no Ofox model page. Use the Gemini API paid tier directly. Claude Opus 5.5 and GPT-6.2 Sol are both available on Ofox.


