Back to articles

AI models

Gemini 4 Neon Benchmarks: Real Cost per Agent Task (2026)

Gemini 4 Neon benchmarks show real cost per agent task versus pricier rivals, plus how your input-to-output ratio affects routing in 2026.

Gemini 4 NeonAI AgentsLLM PricingBenchmarksModel Routing
O-mega Team
O-mega Team
•

71 min read

Google's new middle model scores 61 on the leading independent index, tops the coding agent leaderboard and costs less per agent task than every Anthropic flagship. On one widely cited test it is still not the cheapest way to reach its score, and why that is so is the most useful thing to understand before you route agents to it.

The chart Google published with Gemini 4 Neon compares it with exactly two outside models: Claude Opus 5.5 and GPT-6.2 Sol - Google. Neither of them is above Neon on the index that chart plots. The Artificial Analysis Intelligence Index ranks Neon third, behind Claude Fable 5.2 at 65 and GPT-6.2 Astra at 62 - Artificial Analysis. Google's own announcement is candid about it, describing Neon as "landing just behind larger, slower models."

Those two missing models matter for a cost question. On that same leaderboard, GPT-6.2 Astra scores 62 for $4.00 per task at its maximum setting, while Neon's 61 at its top setting costs $6.44 - Artificial Analysis. Astra charges more than twice Neon's price per token and still finishes the index's tasks for less. Yet on the three leaderboards built from agent work rather than question answering (the Vals Index, Arena's Agent Arena and the Artificial Analysis Coding Agent Index), Neon beats Astra on both score and cost, often by a wide margin. Both results are true, and the reason they diverge is the single most practical thing to know about pricing agents in late 2026.

Here are the facts this guide starts from. Gemini 4 Neon was released on November 18, 2026, at $3 per million input tokens, $0.15 per million cached input tokens and $15 per million output tokens, flat across a 1M context window - Google AI Studio. The same price sheet shows Gemini 4 Carbon and Gemini 4 Argon moving from $2 and $10 to $4 and $20 on December 1. Google says Neon is #1 on the Artificial Analysis Coding Agent Index and #2 on the Vals Index, and that at its default setting it costs 32% less per task than Carbon.

This guide works through what that adds up to for anyone running AI agents. It covers what Neon is and where it sits in Google's lineup, every price on its sheet and the December 1 change around it, Google's benchmarks read line by line, what four independent leaderboards measured, and then the core of the piece: what an agent task actually costs on Neon, why the per-token price misleads in both directions, and a cost model you can apply to your own workload. It ends with worked examples, a scored comparison against the alternatives, the model's failure modes, and a migration and routing playbook.

This guide reflects Gemini 4 Neon, its prices and its competitors as of November 21, 2026, three days after launch. Leaderboard positions are still moving as more runs complete, and Google's price sheet changes on December 1, 2026, so verify current figures on the linked pages before committing a budget.

Contents

  1. What Gemini 4 Neon Is and Where It Sits
  2. Every Price on the Sheet, and the December 1 Doubling
  3. Google's Benchmarks, Read Line by Line
  4. The Independent Leaderboards: Four Views of One Model
  5. Cost per Task: What Four Leaderboards Measured
  6. Why the Token Price Misleads: A Cost Model From First Principles
  7. Thinking Levels: The Dial That Sets the Bill
  8. Worked Examples: Three Agent Tasks, Priced
  9. The Harness Effect: Why One Test Says 12.8% and 39.0%
  10. Neon Against the Field: A Scored Ranking for Agent Work
  11. Where Neon Fails
  12. Access, Limits and the Subscription Route
  13. A Migration and Routing Playbook
  14. The Market Around Neon: Agents That Spend Money
  15. Outlook and Verdict

1. What Gemini 4 Neon Is and Where It Sits

Gemini 4 Neon is the fourth model in Google's Gemini 4 family and, by Google's own description, the one meant for "high-frequency complex tasks." It sits between Gemini 4 Hydrogen, the fast everyday model, and Gemini 4 Carbon, the model Google keeps for its hardest long-horizon work - Google AI Studio. The announcement came from Koray Kavukcuoglu, Google DeepMind's SVP and Google's Chief AI Architect, who framed it as frontier-level intelligence "with fast end-to-end task completion across complex software engineering, knowledge work, and science workflows" - Google.

The most revealing line about the model is in its model card, not its launch post: "Gemini 4 Neon is adapted from Gemini 4 Carbon" - Google DeepMind. The card repeats that sentence for the architecture, the training data, the hardware and the software, and gives Neon a knowledge cutoff of March 2026. Google does not say how the adaptation was done. What the published numbers show is a model with Carbon's capability ceiling that finishes work in far less time: Artificial Analysis measured Neon generating about 110 tokens per second against Carbon's 57, and completing an average index task in about 21 minutes against Carbon's 36 - Artificial Analysis. A model that matches its parent while running nearly twice as fast is, almost by definition, cheaper to serve, and Google has priced it accordingly: Neon's list price is 25% below the list price Carbon moves to on December 1.

Four models in seven weeks

Neon arrived at the end of an unusually fast release run, which Artificial Analysis summed up as Google DeepMind's "fourth model in seven weeks." Gemini 4 Argon was first announced on September 30 for cyber defenders in Google's Fairwind Program - Google and became generally available on October 13. Carbon was announced on October 28 - 9to5Google.

Carbon then reached general availability on November 10 with an introductory price that "expires on November 30, 2026" - Google. Hydrogen followed on November 12, and Neon six days later.

The pace matters for a buyer because it compresses the useful life of any comparison. A team that picked Carbon on November 10 because it was the best Gemini model available picked a model that, eight days later, was matched by a cheaper and faster sibling, and that will cost twice as much from December 1. Neon itself may be outdated by the next release in the same way. The durable lesson is to build agents so that the model is a setting rather than a foundation, which the routing section of this guide returns to.

How Google wants you to choose

Google's developer documentation is explicit about the division of labour. Hydrogen is "fast and cost-efficient for everyday coding and agentic workflows" and the default for "parallel worker subagents." Neon is for "multi-file refactoring, repository-wide debugging, and analytical tasks where a developer or coding agent is waiting on the response." Carbon is for "multi-hour background runs, deep research, formal proofs, and security audits," or as the model to escalate to "when Neon at high or xhigh thinking gets stuck" - Google AI Studio. The same page carries a one-glance summary of the three tiers.

Two details on that card are worth noticing. The speed column gives Neon four of five marks and Carbon two, which is the single biggest difference between them. And the thinking levels differ: Neon defaults to high and adds an xhigh level, while Carbon defaults to medium and stops at high. That second detail has a cost consequence for anyone migrating, because a request that does not set a thinking level will reason harder on Neon than it did on Carbon.

The specification, in plain terms

Neon accepts text, images, audio, video and PDFs and returns text. Its 1,048,576-token window is unified: input, thinking and output tokens all share it. A single synchronous response is capped at 65,536 tokens by default, and "long decode" lets a response run to the full window through background execution - Google AI Studio. It supports function calling, structured outputs, code execution, computer use, file search, URL context and grounding with Google Search and Google Maps. It does not generate images or audio, it does not run in the Live API, and it supports only implicit context caching, not the explicit caches older Gemini models offered. Each of those limits shapes what an agent built on Neon costs, and they come back in the sections on caching and migration.

For a deeper look at the two siblings Neon sits between, see our guides to Gemini 4 Hydrogen's benchmarks and cost and to choosing between Carbon, Argon and Hydrogen, both written before Neon existed and both still accurate about the other three models.

2. Every Price on the Sheet, and the December 1 Doubling

Neon has one of the simplest price sheets of any frontier model. There is no free tier, no introductory discount, no surcharge for long prompts and no scheduled change. What it does have is four service tiers and a billing rule that matters more than any of them.

Gemini 4 modelStandard input / output per 1MCached input per 1MBatch and Flex (in / out)Priority (in / out)Change on Dec 1, 2026
Neon$3.00 / $15.00$0.15$1.50 / $7.50$5.40 / $27.00None
Hydrogen$1.50 / $7.50$0.075$0.75 / $3.75$2.70 / $13.50None
Carbon$2.00 / $10.00 until Nov 30$0.10$1.00 / $5.00$3.60 / $18.00Doubles to $4.00 / $20.00
Argon$2.00 / $10.00 until Nov 30$0.10$1.00 / $5.00$3.60 / $18.00Doubles to $4.00 / $20.00

Every figure in that table is from Google's own pricing page, which states Carbon's rate as "$2.00 through November 30, 2026" and "$4.00 starting December 1, 2026," and doubles every tier with it - Google AI Studio. Batch and Flex cost half the standard rate for work that can wait; Priority costs 80% more for traffic that must not be shed under load.

The rule that sets the bill: thinking is output

The line on Google's migration page that decides what you pay is easy to skim past: "We count and bill every token the model processes, including thinking tokens and internal grounding system instructions and function declarations" - Google AI Studio. Neon reasons before it answers, that reasoning is billed at the $15 output rate, and at its default high level it reasons a great deal. Artificial Analysis counted 123 million output tokens for Neon to complete its index at high and 283 million at xhigh, against a median of 65.4 million across the models it tracks, and labelled Neon at xhigh "very verbose" - Artificial Analysis. The output price is therefore not the price of the answer you read. It is the price of everything the model thought on the way to it.

Three other lines on the sheet move real money. Grounding with Google Search is free for 5,000 requests a month (shared across Gemini 3 and later models) and then costs $14 per 1,000 requests, on top of the tokens. Caching is implicit only: Google applies it automatically to prompts of at least 4,096 tokens and discounts cache hits by 95%, but you cannot create or pin a cache yourself - Google AI Studio. And there is no long-context tier, which is a genuine difference from OpenAI, whose GPT-6.2 Astra rises to $16 input and $60 output per million on prompts above 272,000 tokens - OpenAI. An agent that carries a 400,000-token codebase in context pays Neon's flat rate on every token of it.

On Google Cloud, Neon is also served through Vertex AI. OpenRouter's listing shows the Vertex global endpoint at the same $3 and $15 and Vertex's EU in-region routing at $3.30 and $16.50, a 10% premium for keeping traffic in Europe - OpenRouter.

Why December 1 is the date that matters

Until November 30, Carbon is cheaper per token than Neon: $2 against $3 for input, $10 against $15 for output. From December 1 the order flips, and Carbon becomes a third more expensive per token than Neon. Combined with Neon's leaner reasoning at the same score (section 6), that turns a close call into a lopsided one. Artificial Analysis put Neon at high "at under half of Carbon's cost per task, using Carbon's standard pricing" - Artificial Analysis. Any team running Carbon today on the strength of its introductory price should treat December 1 as a migration deadline rather than a billing footnote.

The competitors' sheets

For context, here are the per-token prices of the models Neon is most often compared with. GPT-6.2 Astra lists at $8 input and $40 output, with cached input at $0.40. GPT-6.2 Sol lists at $2 and $10, with cached input at $0.10. Anthropic prices Claude Fable 5.2 at $8 and $40 with cache hits at $0.20 - Anthropic. Claude Opus 5.5 is $4 and $20, and Claude Sonnet 5.5 is $2 and $10.

On paper, then, Neon is a mid-priced model: dearer than Sol, Sonnet and Hydrogen per token, cheaper than Opus, Astra and Fable. The rest of this guide is about why "on paper" is the wrong place to stop. For a wider price table across every model agents commonly run on, see our cheapest LLM APIs for AI agents.

3. Google's Benchmarks, Read Line by Line

Google's launch table puts Neon beside Claude Opus 5.5 and GPT-6.2 Sol on 19 results across capability indices, agentic coding, knowledge work, science, reasoning, multimodal understanding, long context and cybersecurity.

Read the table in three passes, using the figures as Google published them - Google. First, where Neon wins clearly: AutomationBench (56.3% against Opus 5.5's 42.5% and Sol's 41.3%), GraphWalks long-context reasoning between 256,000 and 1 million tokens (95.2% against 66.8% and 80.1%), HLE-Diamond (71.3% against 67.9% and 64.0%) and CursorBench 4.1 (65.4% against Opus's 58.1%). Second, where it loses or ties: Opus 5.5 is ahead on Terminal-Bench 4.1 (65.8% against 65.2%) and FrontierCode 2.0 (47.3% against 46.2%), and Sol is ahead on Chartography (75.1% against 73.5%). Third, where the comparison is not like for like, which is the subject of section 9: on SWE-sweep, Neon's 39.0% in its own harness is set against Opus's 10.1% and Sol's 8.3% in theirs.

What the methodology notes say

Google's evaluation document is short and worth reading in full, because it changes how much weight each row can carry. "All the results for non-Gemini models are sourced from providers' self-reported numbers unless otherwise mentioned," it says, and for Opus 5.5 and Sol it reports "maximum thinking/reasoning settings available" where those exist - Google DeepMind. Neon's own results are run "with the highest thinking settings unless indicated otherwise," which means xhigh, except FrontierCode 2.0, which uses high. Several of Neon's results are "self-computed" in Google's own Antigravity CLI harness, version 1.5.9 or 1.4.8.

None of that is unusual for a launch table, but it means the table compares numbers produced by different people, in different harnesses, at settings chosen to flatter each model. It is evidence of where Neon is strong, not a controlled experiment.

The rows that are missing

The more important point is who is not in the table. Claude Fable 5.2 and GPT-6.2 Astra, the two models ranked above Neon on the Artificial Analysis index, do not appear. Where their numbers are public, they are often ahead. Anthropic reports Fable 5.2 at 49.1% on FrontierCode 2.0 at its xhigh setting, "the highest score of any released model we've tested," against Neon's 46.2% - Anthropic. Artificial Analysis's own runs put Fable 5.2 ahead on HLE-Diamond (80% against Neon's 71%) and on its agentic knowledge work benchmark (section 4).

A fair reading is that Google picked the comparison it wins: Neon against the models it is priced near, at their best settings, rather than against the two that cost more per token and score higher. That is a legitimate marketing choice, and the table is honest about what it shows. It just does not answer the question of whether Neon is the best model for a given job.

Cost claims and safety numbers

Google makes three cost claims in its announcement - Google. At high, Neon "pairs a high Artificial Analysis Intelligence Index score with a 32% lower cost per task than Carbon." On the Vals Index and Agent Arena it "sits on the Pareto frontier" at high, with "roughly 50% to 80% lower cost per task than top competing frontier models." And at xhigh it costs "36%+ less per task than competing models at their highest setting." Section 5 checks each of these against the leaderboards they cite; the first two hold up, and the third depends on which competitors you count.

The safety figures are Google's own and should be read as such. Google reports a 0.09% misaligned action rate on its agentic safety suite, a 99.2% pass rate on its agent honesty evaluation, shortcuts on 2.45% of coding cheating-evaluation tasks ("the lowest of any Gemini 4 model"), and a 0.0% attack success rate on Gray Swan's indirect prompt injection benchmark at the highest thinking level. That last one is the most relevant to agents that read untrusted web pages and documents, and the methodology note says Gray Swan evaluated it using 1,810 curated attacks across four inference trials. The full Safety & Security report, the model card says, "will be available in the coming days" - Google DeepMind, so the detail behind those numbers was not yet public at launch.

On cybersecurity, which Google treats as a headline capability for the whole Gemini 4 family, Neon reports 51.3% on WebExploitBench v1.2 (against Opus 5.5's 37.1%), 90.5% on SEC-bench Pro and 70.7% on CWE-Bench v2 - Google. Its most capable offensive-security abilities are reserved for verified defenders through the Fairwind Program.

4. The Independent Leaderboards: Four Views of One Model

Four independent evaluators had results for Neon within a day of launch, each measuring something different. Read together they give a far more useful picture than any single number.

Artificial Analysis Intelligence Index: 61, third place

The Artificial Analysis Intelligence Index is the broadest of the four: a composite of private and held-out evaluations across knowledge, reasoning, coding, science and agentic work. Neon scores 61 at xhigh, 60 at high, 55 at medium and 44 at low. Counting each model once, that is third place behind Claude Fable 5.2 (65) and GPT-6.2 Astra (62), and one point ahead of Carbon (60). Artificial Analysis lists every effort setting as its own row, which is why the same page also describes Neon at xhigh as "#6 of 95" - Artificial Analysis.

The sub-evaluations behind that score, published in Artificial Analysis's launch analysis - Artificial Analysis, show a model with a distinct profile rather than a uniformly strong one. On AutomationBench-AA (agentic SaaS workflows), Neon at xhigh and high both score 79%, the top of the board. On GDP.pdf (professional document reasoning), Neon at high scores 33.4%, which Artificial Analysis called "in line with the highest measured," while Neon at xhigh drops to 28.0%. On AA-Briefcase (agentic knowledge work, scored as an Elo rating), Neon at xhigh reaches 1,700, behind Claude Sonnet 5.5 (1,815), Claude Opus 5.5 (1,800) and Claude Fable 5.2 (1,785), but Artificial Analysis singled out its 1,771 on Presentation Quality, 45 points above the previous leader. On Terminal-Bench 4.0, Neon at xhigh scores 64%, behind Kimi K3.1 Pro (67%) and Carbon (65%). And on FrontierCode-AA 2.0, Neon at xhigh scores 44%, behind Fable 5.2 (49%), Opus 5.5 (46%) and Astra (45%).

The most striking pair of results is about honesty, again from the Artificial Analysis evaluation charts - Artificial Analysis. On AA-Omniscience, which asks hard factual questions and penalises confident wrong answers, Neon answers 60% correctly at xhigh, well behind Fable 5.2's 79% and Astra's 69%. But its non-hallucination rate, the share of questions it does not answer wrongly when it does not know, is 86%, against 41% for both Fable 5.2 and Astra. Neon knows less than the two leaders and admits it far more often. For an agent that will act on what it believes, that trade can be worth more than the extra knowledge.

Vals Index: 70.87%, second place

The Vals Index is closer to paid work. It is a GDP-weighted average of agentic benchmarks across finance (weight 8.0), coding (5.6), legal (1.2) and tax (0.5). Neon scores 70.87%, second to Claude Fable 5.2's 71.31% and a statistical hair ahead of Claude Sonnet 5.5 (70.85%), Carbon (70.45%) and Opus 5.5 (70.14%) - Vals AI. GPT-6.2 Astra is eighth at 67.66% and Sol tenth at 66.06%. Google says Neon is #1 on two of the index's components, Legal Research Bench and Tax Agent Bench - Google.

Five models within 1.2 points of each other is the more important observation. On this kind of work the frontier is crowded, and the model you choose matters less for quality than for what each attempt costs and how long it takes, which is where Vals' other two columns come in (section 5).

Agent Arena: 1,333, third place and still preliminary

Arena's Agent Arena ranks models from real user sessions in its Agent Mode rather than from fixed test sets, turning each session into per-signal scores. Google's post cited Neon at #2 with 1,336 across 4,200-plus sessions - Google. By the time of writing, the leaderboard showed Neon (at high, marked "Preliminary") at 1,333 in third place, a point behind Claude Opus 5.5 at its maximum setting (1,336) and well behind Claude Fable 5.2 at 1,448 - Arena. OfficeChai, reporting the same board, noted that the gap between Neon and Opus "is within the margin of error, so they should be treated as tied" - OfficeChai.

The coding-specific view on Arena is less flattering and more instructive. On Arena's Coding Index, Neon at high ranks #5 of 68 with 1,325 ± 44, behind Fable 5.2, Opus 5.5, Astra and Sonnet 5.5. Its best signal is Steerability (#2 of 68), how well it responds when a user pushes back. Its worst is Bash Reliability, how often its shell commands succeed: #57 of 68 - Arena. A model that takes correction well but whose commands fail more often than most is a model whose results depend heavily on the harness around it, which is exactly what section 9 finds.

Artificial Analysis Coding Agent Index: 59, first place

The Coding Agent Index (version 2.1) measures a model inside a coding harness, as an agent variant rather than a bare model: an equal-weight average of FrontierCode-AA 2.0 (132 tasks), Terminal-Bench 4.1 (66 tasks) and SWE-Atlas-QnA-AA (124 tasks), each attempted three times - Artificial Analysis. Neon in the Antigravity CLI at xhigh scores 59, ahead of Claude Code running Fable 5.2 at xhigh (58) and Claude Code running Opus 5.5 at maximum effort (58). Carbon scores 55, Meta's Muse Code with Wonder Full 54, and OpenAI's Codex with GPT-6.2 Astra 53, according to OfficeChai's reading of the Artificial Analysis board - OfficeChai. Google's post gives Neon's score as 58.6.

A one-point lead on a three-benchmark index is not a decisive win in quality. It is, however, a decisive win in price, because the three agents at the top cost very different amounts to run (section 5).

A first look on camera

Arena published a 30-minute first-impressions video the day after launch, comparing Neon's outputs side by side with Opus, Fable, Astra and Sol. It is the most useful video on the model so far because it comes from one of the evaluators Google itself cites, and it ends with a measured verdict rather than a headline.

The pricing discussion comes in the final third, around the 23:36 mark, and the reviewer's overall view is that there is still a gap between Neon and the strongest models. That matches the leaderboards: Neon is close to the top on almost every board and at the top of very few, and its case rests on what it charges for being close.

For background on how each of these evaluations is built and which ones still discriminate between frontier models, see our guide to AI agent evals and benchmarks.

5. Cost per Task: What Four Leaderboards Measured

Every evaluator above also measured what a task cost, and each did it differently. That makes them more useful together than apart: where four methods agree, the result is robust, and where they disagree, the disagreement tells you something about the workload.

Artificial Analysis: cost per Intelligence Index task

Artificial Analysis computes a weighted average cost per index task from each model's token usage at the provider's list price, with Carbon priced at its standard rather than its introductory rate. Neon at xhigh costs $6.44 per task, about 17% less than Carbon at high ($7.76), and Neon at high costs $3.74 for the same score of 60 that Carbon reaches for more than twice as much - Artificial Analysis. Here is the full field at each model's top listed setting, with Neon's four levels added.

This is the board on which Neon is not the bargain. GPT-6.2 Astra at maximum effort scores 62 for $4.00, a point more than Neon's best for 38% less money. Sol at maximum effort reaches 57 for $1.01. And Artificial Analysis's own scatter of score against cost draws its Pareto line (the set of models nothing else beats on both axes at once) through Astra and Sol, with Neon at xhigh sitting just below it - Artificial Analysis.

The same figures let you check two of Google's three cost claims. Google's "32% lower cost per task than Carbon" at high - Google is, if anything, conservative against Carbon's standard price: on Artificial Analysis's numbers Neon at high costs 52% less ($3.74 against $7.76). Against Carbon's introductory price, which halves every token, Carbon would cost about $3.88 and the two would be roughly level, which is why the gap only opens up on December 1. Google's "36%+ less per task than competing models at their highest setting" for xhigh holds exactly against Claude Opus 5.5 ($6.44 against $10.04) and Claude Sonnet 5.5 ($10.02), and by a wide margin against Fable 5.2, but not against OpenAI: Neon at xhigh costs 61% more than Astra at maximum and more than six times as much as Sol.

In the bar chart, each model's bar is split by token type, and Neon's xhigh bar shows reasoning tokens as its largest segment. In the scatter below it, the green Gemini points sit to the right of the OpenAI points at similar heights: the same score, bought with more money. That is the board Google's cost chart did not show. Google plotted Neon only against Carbon, Opus 5.5 and Sol, and against those three its claim holds: Neon's curve sits above and to the left of Opus 5.5 at every setting.

Notice that in Google's own chart, GPT-6.2 Sol's points sit at the far left, reaching the high 50s for about a dollar. Google did not hide that Sol is cheaper; it showed that Neon buys more score per extra dollar than anything else it chose to plot.

Vals AI: cost per test on GDP-weighted agent work

Vals reports a cost and a duration for every model's full run of its index, and here the picture reverses. Neon costs $7.40 per test and takes about 31 minutes, against $17.94 and 44 minutes for Claude Fable 5.2, $16.18 and an hour and 26 minutes for Sonnet 5.5, and $24.77 for Opus 5.5. GPT-6.2 Astra costs $10.68, more than Neon, while scoring three points lower - Vals AI.

Two oddities in that chart deserve attention. Neon is cheaper than Hydrogen here, despite costing twice as much per token, which means Hydrogen used more than twice Neon's tokens to finish the same work. And Carbon's $10.51 may or may not reflect its introductory price; Vals does not say. If it does, Carbon's real cost from December 1 would be about twice that.

Agent Arena: realized cost of real sessions

Arena's figures come closest to a real bill. It reports the median cost per task over the last 14 days of real Agent Mode sessions, which its methodology describes as the "realized, post-deployment cost of the agents" - Arena.

On that measure, Neon at high runs at a median of $2.52 and 8.2 minutes per task, against $5.65 and 18.1 minutes for Opus 5.5 at maximum and $9.12 and 19.2 minutes for Fable 5.2 at maximum - Arena.

Among the five models at the top of this board (Fable 5.2, Opus 5.5, Neon, Carbon and Sonnet 5.5), Neon is the second cheapest per task and the fastest. Carbon is cheaper still, at $1.35, but that median is taken over a period in which Carbon was billed at its introductory price; from December 1 every one of its tokens costs twice as much. Arena does not publish which price it applies, so treat Carbon's figure as a lower bound.

Coding Agent Index: cost per coding task

Artificial Analysis prices its coding-agent runs at provider pay-per-token rates with live measurements of cache hit rates, including cache-write charges where a provider bills them. On that basis, Neon in the Antigravity CLI averages $6.86 per coding task, against $12.61 for Claude Code with Opus 5.5 at maximum effort and $15.47 for Claude Code with Fable 5.2 at xhigh, for scores of 59, 58 and 58 - Artificial Analysis. In other words, the three best coding agents measured are roughly equal in quality, and the Google one costs about half as much as the cheaper of the two Anthropic ones.

What the four boards agree on

Put the four together and a consistent shape appears.

LeaderboardWhat it measuresNeon's costCheapest top-five rivalMost expensive top-five rival
AA Intelligence IndexKnowledge, reasoning, coding, science tasks$6.44 (xhigh), $3.74 (high)GPT-6.2 Astra max, $4.00Fable 5.2 max, $26.54
Vals IndexGDP-weighted finance, coding, legal, tax agents$7.40Carbon, $10.51Opus 5.5, $24.77
Agent ArenaReal user agent sessions, median$2.52Carbon high, $1.35 (intro price)Fable 5.2 max, $9.12
AA Coding Agent IndexModel inside a coding harness$6.86Opus 5.5 in Claude Code, $12.61 (of rivals with a published cost)Fable 5.2 in Claude Code, $15.47

On the three boards built from agent work, Neon is the cheapest or second-cheapest frontier-class option, at roughly 30% to 55% of what Anthropic's flagships cost for comparable quality. Google's "50% to 80% lower cost per task" claim, which it made specifically for Vals and Agent Arena, checks out against Opus 5.5 and Fable 5.2 on both. On the one board built mostly from single questions, GPT-6.2 Astra reaches a higher score for less.

Artificial Analysis showed what that gap looks like on a single real task in its AA-Briefcase evaluation, publishing two answers to the same investment-analysis brief side by side.

Neon's slide cost $4.03; Claude Opus 5.5's answer to the same brief cost $30.06. Both are competent, dense deliverables. Across the whole AA-Briefcase benchmark Opus 5.5 still rates higher (1,800 Elo against Neon's 1,700) - Artificial Analysis, so the comparison is not that Neon is better, but that closing the quality gap costs more than seven times as much on this task. Whether that is worth paying depends entirely on what the deliverable is for.

6. Why the Token Price Misleads: A Cost Model From First Principles

The question behind every cost comparison in this guide is simple to state: why does GPT-6.2 Astra, at $8 and $40 per million tokens, finish an Artificial Analysis index task for less than Neon at $3 and $15, while Neon finishes a Vals or Arena agent task for far less than Astra? The answer comes from breaking an agent task into what is actually billed.

What an agent task is made of

A single agent task is not one call. It is a loop: the model reads its instructions, the tools available and everything that has happened so far, decides what to do, calls a tool, receives the result, and repeats until it is done or gives up. Every turn re-sends the whole history as input. Every turn produces some thinking and some action as output. And the task as a whole either succeeds or must be retried or fixed by a person.

So the cost of one attempt is:

Cost per attempt = (uncached input tokens x input price) + (cached input tokens x cache price) + (output tokens, including thinking, x output price)

and the cost of a finished task divides that by the success rate and adds what a failure costs you. Two features of agents make this formula behave differently from a chat bill. First, input grows with every turn, because history accumulates, so long tasks are dominated by input tokens, most of which are cache hits on the stable early part of the conversation. Second, output depends on how much the model chooses to think, which varies enormously between models that reach the same score.

Two models, two cost structures

Neon and Astra are priced on opposite philosophies. Neon is cheap per token and spends many of them. Astra is expensive per token and spends few. The Artificial Analysis model pages make the second half measurable, because they publish how many output tokens each model used to complete the whole index at each setting.

At a score of 60, Neon at high used 123 million output tokens and Astra at high used 20 million, about a sixth as many - Artificial Analysis. Multiply by the output prices and Neon's output bill for the whole index is about $1,845 (123 million at $15), while Astra's is about $800 (20 million at $40). At the top settings the gap widens: Neon at xhigh spent about $4,245 on output to score 61, Astra at xhigh about $1,084 to score 62. Those are our multiplications of Artificial Analysis's published token counts by list prices, and they explain the index result completely. On work that is mostly thinking and answering, Astra's frugality beats Neon's low rate.

Now flip to input. Neon charges $3 per million uncached input tokens and $0.15 cached; Astra charges $8 and $0.40. Neon is 62.5% cheaper on every input token, cached or not. In an agent loop that re-reads 50,000 or 100,000 tokens of history on every turn, input is most of the bill, and there Neon's rate card wins regardless of how much the models think.

The crossover: where Neon becomes cheaper than Astra

You can turn this into a rule of thumb. Write the uncached input as Iu, the cached input as Ic and Neon's output as O, and assume Astra produces about a sixth of Neon's output for the same work (the ratio Artificial Analysis measured at high). Per million tokens:

  • Neon costs 3 Iu + 0.15 Ic + 15 O
  • Astra costs 8 Iu + 0.40 Ic + 40 x (O / 6), or about 6.7 O

Astra is cheaper only when 5 Iu + 0.25 Ic is smaller than about 8.3 O. With no caching at all, that means Astra wins when a task reads less than about 1.7 input tokens per output token Neon would write. With a 90% cache hit rate, typical of a long agent loop with a stable prefix, Astra wins below about 11.5 input tokens per Neon output token, and Neon wins above it.

That single ratio sorts real workloads cleanly. A reasoning question, a short analysis or a one-shot generation reads little and thinks a lot, so it sits below the crossover and Astra is cheaper. A coding agent working through a repository, a browser agent reading pages, or a research agent accumulating sources reads 20 to 100 tokens for every token it writes, so it sits far above the crossover and Neon is cheaper. The Artificial Analysis index is mostly the first kind of work; Vals, Arena and the Coding Agent Index are mostly the second. The leaderboards are not contradicting each other. They are measuring two different shapes of task.

Two caveats keep this honest. The one-sixth output ratio comes from the index runs and will not hold exactly on your tasks; measure it. And the comparison assumes both models take the same number of turns, which they will not: a model that reaches the answer in fewer turns saves input on every turn it skips. Google claims Neon "reduces redundant file reads" in long sessions, which, if it holds on your work, pushes the crossover further in Neon's favour.

Against Sol, the arithmetic is simpler

GPT-6.2 Sol is cheaper than Neon on every token type ($2, $0.10 and $10 against $3, $0.15 and $15) and uses fewer output tokens per index point: 22.7 million at high for a score of 55, against Neon's 62.9 million at medium for the same 55 - Artificial Analysis. There is no crossover. Per attempt, Sol is always cheaper. The only question is whether Sol's lower ceiling (66.06% on Vals against Neon's 70.87%, 57 on the index against 61) costs you more in failed tasks than it saves in tokens.

Cost per finished task: where the real money is

That last question is the one most cost comparisons skip, and at the frontier it usually decides the answer. Suppose a failed agent task costs you nothing but a retry. Then cost per success is cost per attempt divided by success rate, and a cheaper model with a slightly lower success rate still wins. Now suppose, more realistically for production work, that a failure costs a person 15 minutes to notice, diagnose and redo, valued at $25. Then a model that succeeds 65% of the time instead of 60% saves 0.05 x $25 = $1.25 per task in human time, which is more than the entire token cost of most agent tasks in section 8.

That is the economic logic of paying for the frontier: once token costs fall to a few dollars per task, the success rate is worth more than the rate card. It cuts both ways for Neon. Against Opus 5.5 and Fable 5.2, Neon is close enough in quality on agent work that its lower price usually wins. Against Sol and Hydrogen, Neon's higher success rate is the thing you are paying for, and it is worth it only when failures are expensive. For the general version of this argument, see our analysis of the true cost of LLM inference.

7. Thinking Levels: The Dial That Sets the Bill

Before choosing between models, Google's own advice is to tune the thinking level, and for Neon that advice is worth taking literally. The four levels span a nearly ninefold range in cost per task.

Neon thinking levelAA index scoreCost per index taskTime per taskOutput tokens, whole indexTime to first answer token
low44$0.753.7 min28.3M13.9 s
medium55$1.908.3 min62.9M20.1 s
high (default)60$3.7414.8 min123M40.6 s
xhigh61$6.4421.5 min283M56.5 s

The scores, times and token counts are from Neon's Artificial Analysis model page, and the cost per task at each level from Artificial Analysis's launch charts - Artificial Analysis. Read down the table and the returns fall off a cliff. Going from low to medium adds 11 points for $1.15. Going from medium to high adds 5 points for $1.84. Going from high to xhigh adds one point for $2.70.

The last step costs more than 25 times as much per point as the first. Google's documentation says the same thing in words: reserve xhigh "for hard, multi-step engineering, analytical, and scientific problems where high falls short, when you can trade higher latency and token use" - Google AI Studio. It recommends running your evaluations at all four levels "with a high max_output_tokens so the limit doesn't cut answers short," then picking the lowest level that meets your bar.

More thinking is not always better

The xhigh level does not just cost more; on some work it does worse. On Artificial Analysis's GDP.pdf document-reasoning evaluation, Neon at high scored 33.4% and at xhigh 28.0%, a drop of more than five points for more than twice the tokens. WinBuzzer, reporting the same runs, put it plainly: xhigh "added one benchmark point but more than doubled billable output tokens" - WinBuzzer. Overthinking is a real failure mode for document tasks, where extended reasoning can talk a model out of an answer it read correctly.

Practical settings by task type

The level that fits depends on whether someone is waiting and how hard the step is, not on the model. Google's own guidance (an illustration, not a rule) maps low to fast chat and high-throughput processing, medium to interactive coding and latency-sensitive tool calls, high to complex coding, agentic execution and multimodal knowledge work, and xhigh to the hardest multi-step problems. In an agent, a sensible pattern is to run routine tool-calling turns at medium or high and raise the level only for the planning turn or for a step that has already failed once. Because the thinking level is a per-request parameter, an agent can change it turn by turn without changing model.

There is one migration trap here. Carbon and Argon default to medium; Neon defaults to high. A team that swaps the model ID from Carbon to Neon and changes nothing else is moving its agent to a higher reasoning level at the same time, which raises output tokens per turn. Set thinking_level explicitly when you migrate, and compare like with like.

8. Worked Examples: Three Agent Tasks, Priced

Benchmarks average over hundreds of tasks. A budget is built from your own. Here are three common agent task shapes priced on Neon and its rivals, using list prices from section 2. The token counts are illustrative assumptions, not measurements, chosen to be typical of each shape; the output-token ratios between models are taken from the Artificial Analysis index runs in section 6, which is a simplification you should replace with your own measurements.

Example A: a coding agent fixing a bug across a repository

Assume 40 turns, an average of 70,000 tokens of context per turn (2.8 million input tokens in total), a 90% cache hit rate, and 1,500 output tokens per turn on Neon at high (60,000 in total). Other models' output is scaled by their measured ratio to Neon at a comparable setting.

Model and settingUncached inputCached inputOutputCost per attempt
GPT-6.2 Sol high$0.56$0.25$0.11 (11,100 tokens)$0.92
Gemini 4 Hydrogen high$0.42$0.19$0.40 (53,700 tokens)$1.01
Gemini 4 Neon high$0.84$0.38$0.90 (60,000 tokens)$2.12
Gemini 4 Carbon high, from Dec 1$1.12$0.50$2.00 (100,000 tokens)$3.62
GPT-6.2 Astra high$2.24$1.01$0.39 (9,800 tokens)$3.64
Claude Opus 5.5 max$1.12$0.50$2.13 (106,300 tokens)$3.75
Claude Fable 5.2 high$2.24$0.50$1.66 (41,600 tokens)$4.41

Three things stand out. First, this task reads 47 input tokens for every Neon output token, far above the crossover, so Neon costs 42% less than Astra even though Astra writes a sixth as much. Second, Carbon from December 1 costs 71% more than Neon for this task; before December 1 it would cost $1.81, slightly less. Third, Sol and Hydrogen cost under half of Neon per attempt, which is the real competition for routine coding work: the question is whether Neon's higher success rate on hard repository tasks is worth roughly a dollar more per attempt. On the human-time arithmetic of section 6, it is when a failure costs you more than a few minutes of attention.

Example B: analysing a document and writing a report

Assume one call with 20,000 input tokens (uncached) and 40,000 output tokens on Neon at high, most of them thinking.

Model and settingInputOutputCost per attempt
GPT-6.2 Sol high$0.04$0.07 (7,400 tokens)$0.11
GPT-6.2 Astra high$0.16$0.26 (6,500 tokens)$0.42
Gemini 4 Neon high$0.06$0.60 (40,000 tokens)$0.66
Claude Fable 5.2 high$0.16$1.11 (27,700 tokens)$1.27
Gemini 4 Carbon high, from Dec 1$0.08$1.33 (66,700 tokens)$1.41

Here the ratio is 0.5 input tokens per output token, far below the crossover, and the order flips: Astra is 36% cheaper than Neon, and Sol is cheaper still. If most of your workload looks like this (analysis, drafting, one-shot reasoning over a modest input), Neon's rate card is not an advantage, and its verbosity is a cost. Lowering Neon to medium would roughly halve its output tokens, at a cost in quality you would need to test.

Example C: Neon as planner, Hydrogen as workers

Google's recommended pattern for larger jobs pairs a stronger model that plans with cheaper models that execute. In Antigravity, the Orchestrator "supports pairing Gemini 4 Neon as the planner with Gemini 4 Hydrogen as the executor," with Hydrogen taking "routine code edits, package updates, and test runs" and handing back to Neon when it "hits friction" - Google Antigravity. Assume the planner takes 3 turns at 60,000 tokens of context and 4,000 output tokens each, and four workers each take 15 turns at 40,000 tokens of context and 1,000 output tokens each, all with 90% caching.

SetupPlannerFour workersTotal per task
Neon plans, Hydrogen executes$0.26 (Neon)$0.97 (Hydrogen, $0.24 each)$1.23
Neon does everything$0.26 (Neon)$1.94 (Neon, $0.49 each)$2.20

Routing the execution to Hydrogen cuts this task's cost by 44%. The saving is mechanical, because Hydrogen costs exactly half of Neon per token and, at high, used a similar number of output tokens on the index (110 million against Neon's 123 million). The risk is the hand-offs: every time a worker gets stuck and returns to the planner, you pay Neon's rate for the diagnosis. The pattern pays when most of the work is routine and fails to pay when most of it is hard. Google demonstrated the swarm form of this idea in one of its launch clips, in which a group of Neon agents turned a single image into a 100,000-cell Google Sheet driven by more than 500,000 formulas.

The clip is a showcase, not a benchmark, and it says nothing about cost. What it shows well is the structure that makes the cost arithmetic above work: many small, parallel, well-specified subtasks coordinated by one model that holds the plan. For when splitting work across subagents is worth its overhead and when it is not, see our guide to single-agent versus multi-agent designs.

9. The Harness Effect: Why One Test Says 12.8% and 39.0%

The most striking number in Google's launch table is also the most misleading if read alone. On SWE-sweep, a bug-finding benchmark, Neon scores 39.0% against Claude Opus 5.5's 10.1% and GPT-6.2 Sol's 8.3%. One row below, on the same benchmark in a neutral harness called mini-SWE, the scores are 12.8%, 3.6% and 11.6% - Google. Same models, same tasks, a different program around the model, and Neon's lead over Sol shrinks from 30.7 points to 1.2.

Google's evaluation notes explain why. The "provider harness" row runs each model in its maker's own agent: Antigravity CLI for Neon, Claude Code for Opus 5.5 and Codex for Sol. And "the public Antigravity-CLI harness includes a default tool that allows for sub-agents that fan out across the codebase, which is particularly suited to bug finding tasks like SWE-sweep" - Google DeepMind. Google says this openly, which is to its credit. But it means the 39.0% measures Antigravity's fan-out tool at least as much as it measures Neon. Opus 5.5 also gains in its own harness (from 3.6% to 10.1%), while Sol loses (from 11.6% to 8.3%), so harnesses do not even move models in the same direction.

Every agent benchmark is a harness benchmark

This is not a quirk of one test. An agent's result is the product of the model and everything around it: the tools it is given, how its context is compacted, whether it can spawn helpers, how failures are retried, how long it is allowed to run. Several of the strongest results for Neon in this guide were measured inside Google's own harness:

  • The Coding Agent Index score of 59 is for Neon in the Antigravity CLI, set against Claude Code for the Anthropic models and Codex for Astra. Artificial Analysis states that "each public row is an agent variant, not a model" - Artificial Analysis.
  • The Terminal-Bench 4.1 result of 65.2% in Google's table was produced by Artificial Analysis using the public Antigravity-CLI harness version 1.5.9.
  • The Agents' Last Exam result of 75.8% was self-computed by Google in Antigravity CLI 1.4.8 with a five-hour window.

Arena's coding signals hint at what the harness is compensating for - Arena. Neon ranks #2 of 68 on Steerability but #57 of 68 on Bash Reliability, the share of its shell commands that succeed when the failure is within the model's control. A harness with good tools, structured file editing and automatic retries hides a model's shaky shell commands; a thin harness that hands the model a raw terminal exposes them.

What this means for your stack

If you plan to run Neon inside your own agent framework, your own loop, or a third-party tool, you will get the model, not Google's harness, and the provider-harness numbers will not transfer. The neutral-harness numbers are the better guide to what Neon does on its own, and on SWE-sweep those put it level with Sol rather than three times ahead of it. If, instead, you plan to use Neon through Antigravity, the provider-harness numbers are the relevant ones, and they are genuinely strong.

Either way, the practical rule is to evaluate a model in the harness you will deploy it in. A one-day test on 30 of your own tasks, in your own loop, at two thinking levels, will tell you more than every row in this guide. For the longer history of how harness choices have distorted coding benchmarks, see our analysis of why AI coding benchmarks lie, and for the harness Neon was built to run in, our guide to Google Antigravity.

10. Neon Against the Field: A Scored Ranking for Agent Work

To turn four leaderboards into a decision, the table below scores eight frontier models on the four things that decide whether an agent is worth running in production. The criteria and their weights come from the cost model in section 6: capability determines the success rate, cost per task the bill per attempt, speed how many tasks a deployment can finish and whether a person waits, and factual reliability whether the agent acts on things that are not true.

  • Capability (40%): the Vals Index (GDP-weighted agent work), the Agent Arena Index (real sessions) and the Artificial Analysis Intelligence Index, read together.
  • Cost per task (30%): Vals cost per test and Arena's median realized cost per task, the two cost measures built from agent work.
  • Speed (15%): Vals duration per test and Arena's median time per task.
  • Factual reliability (15%): the AA-Omniscience non-hallucination rate, how often a model avoids answering wrongly when it does not know.
#ModelCapability (40%)Cost per task (30%)Speed (15%)Reliability (15%)Final
1Gemini 4 Neon8.5 - Vals 70.87% (#2), Arena 1,333 (#3, preliminary), AA index 61 (#3)8 - $7.40 per Vals test, $2.52 Arena median8.5 - 31 min per Vals test, 8.2 min Arena8.5 - 86% non-hallucination (high and xhigh)8.4
2Gemini 4 Hydrogen6.5 - Vals 68.49%, Arena 1,271, AA 548 - $9.84 per Vals test, $1.50 Arena median9 - 32 min per Vals test, 5.3 min Arena9.5 - 92% non-hallucination (xhigh)7.8
3Gemini 4 Carbon8 - Vals 70.45%, Arena 1,303, AA 606 - $10.51 per Vals test, $1.35 Arena median, list price doubles Dec 16.5 - 48 min per Vals test, 9.3 min Arena9 - 89% non-hallucination (high)7.3
4GPT-6.2 Sol6 - Vals 66.06%, Arena 1,241, AA 5710 - $3.18 per Vals test, $1.01 Arena median7.5 - 42 min per Vals test, 8 min Arena4 - 45% non-hallucination (max)7.1
5GPT-6.2 Astra7.5 - Vals 67.66%, Arena 1,291, AA 62 (#2)6.5 - $10.68 per Vals test, $3.33 Arena median6 - 52 min per Vals test, 11.7 min Arena3.5 - 41% non-hallucination (max)6.4
6Claude Fable 5.210 - Vals 71.31% (#1), Arena 1,448 (#1), AA 65 (#1)3 - $17.94 per Vals test, $9.12 Arena median5 - 44 min per Vals test, 19.2 min Arena3.5 - 41% non-hallucination, but 79% accuracy (max)6.2
7Claude Sonnet 5.57.5 - Vals 70.85%, Arena 1,296, AA 555 - $16.18 per Vals test, $3.68 Arena median3.5 - 86 min per Vals test, 17.2 min Arena5 - 57% non-hallucination (max)5.8
8Claude Opus 5.58 - Vals 70.14%, Arena 1,336 (#2), AA 593 - $24.77 per Vals test, $5.65 Arena median3.5 - 85 min per Vals test, 18.1 min Arena4.5 - 50% non-hallucination (max)5.3

The Vals figures are from the Vals Index v2.2 page, the Arena figures from the Agent Arena leaderboard, and the index scores and non-hallucination rates from Artificial Analysis, all cited in sections 4 and 5. Vals does not state which reasoning setting it ran each model at; the Arena and Artificial Analysis settings are the ones given in those sections.

What the ranking says, and what it does not

Neon ranks first because it is near the top on every criterion and at the bottom of none, which is exactly what its price is designed to buy. It is not the most capable model (Fable 5.2 is, clearly), not the cheapest (Sol is), not the fastest (Hydrogen is) and not the most reliable (Hydrogen again). Its case is the combination.

The ranking is sensitive to weights, and it is worth knowing how. If capability counts for 60% and cost for only 20%, Neon still ranks first at 8.4, but Carbon (7.6) and Fable 5.2 (7.5) move up to second and third. If cost counts for half and capability for 30%, GPT-6.2 Sol edges ahead of Neon (8.3 against 8.25 before rounding), which is the right answer for a team running large volumes of routine work. None of these weightings puts Opus 5.5 or Sonnet 5.5 in the top three, because on these four boards they cost as much as Fable 5.2 without matching its capability; their strengths (Sonnet 5.5 leads AA-Briefcase, for one) sit in work these boards measure only partly.

Two cautions. Carbon's cost score assumes the published figures, part of which may reflect its introductory price; from December 1 its cost per task roughly doubles, which would drop it below Sol. And the non-hallucination criterion rewards models that abstain, which suits agents that act on their beliefs but undersells a model like Fable 5.2 whose raw factual accuracy is the highest measured. For the full monthly ranking across 20 models, including open-weight options, see our best LLM for AI agents ranking, and for the two models directly above Neon on the index, our head-to-head of GPT-6.2 Astra and Claude Fable 5.2.

11. Where Neon Fails

A model this new has failure modes that launch posts do not mention and that only show up in production. Here are the ones the evidence already supports.

Runaway output at xhigh. At xhigh, Neon spent 283 million output tokens on the Artificial Analysis index, ranking #92 of 94 on verbosity - Artificial Analysis. Because thinking is billed as output and max_output_tokens caps thinking and answer together, two things can go wrong. Without a cap, a hard prompt can burn tens of thousands of tokens before answering. With a cap set too low (the 8,192 many older apps hard-code), the model can run out of room mid-thought and return a truncated or empty answer. Google's own advice is to remove low caps, keep the 65,536 default for standard work, and lower the thinking level rather than the cap when you want fewer tokens - Google AI Studio.

Overthinking on documents. As section 7 showed, Neon at xhigh scored more than five points lower than at high on GDP.pdf - Artificial Analysis. On document extraction and reading tasks, test high and medium before assuming more reasoning helps.

Shell commands that fail. Arena's Bash Reliability signal puts Neon at #57 of 68 - Arena. In a harness that gives the model a raw terminal and little structure, expect more failed commands and more retries than the headline coding scores suggest.

Knowledge it does not have. Neon's AA-Omniscience accuracy is 60%, well behind Fable 5.2's 79% - Artificial Analysis, and its knowledge cutoff is March 2026. It is good at saying when it does not know, but it knows less. For agents that need current facts, ground it with Google Search (and budget the $14 per 1,000 requests beyond the free allowance) or give it the documents.

Unsupported claims in generated copy. One outlet's own test is worth noting as a caution rather than a verdict. In WinBuzzer's product-copy experiment, run at medium through OpenRouter, Neon produced publish-ready sales briefs in all three runs for only 32.1% of products and added about one unsupported claim per product, while GPT-6.2 Sol reached 75% - WinBuzzer. A single test at a single setting proves little, but it is a reminder that a strong showing on agent benchmarks does not guarantee careful marketing copy.

Polish on knowledge-work deliverables. On AA-Briefcase, Neon trails all three Anthropic models by 85 to 115 Elo points overall, despite leading on Presentation Quality - Artificial Analysis. If the deliverable is a finished memo or analysis a client will read, Anthropic's models still produce better work on that benchmark.

A stricter API. Google's migration checklist lists several behaviours that break older code - Google AI Studio. Sampling parameters are gone: the server ignores in-range temperature, top_p and top_k values and returns a 400 error for out-of-range ones. The minimal thinking level is rejected. Prompting the model to emit raw JSON tool calls without declaring any tools "can return MALFORMED_FUNCTION_CALL." Thought signatures must be returned unchanged across turns in client-managed histories, and must not be copied across parallel function calls. Explicit caches (cachedContents, caches.create) are not supported. And hard prompts "can take several minutes," so client timeouts should be at least 15 minutes.

A cache you cannot control. Implicit caching only applies to prompts of at least 4,096 tokens and only to the part of the prompt that repeats exactly. An agent that puts a timestamp, a request ID or a changing summary at the top of its prompt will miss the cache on every turn and pay full input price, which, on the arithmetic of example A, would raise Neon's cost for that task from $2.12 to about $9.30. Our guide to prompt caching covers how to structure prompts so the stable part comes first.

Numbers still settling. Neon's Arena rating is marked preliminary and moved from 1,336 at launch to 1,333 three days later. The full Safety & Security report was not yet published at launch. And Google's launch comparisons rely on competitors' self-reported numbers. None of this suggests a problem; it does mean the picture in this guide will sharpen over the coming weeks.

12. Access, Limits and the Subscription Route

Neon is available through more doors than most frontier models, and which one you use changes what you pay.

The Gemini API, paid tier. Neon is on both the generateContent API and the newer Interactions API in Google AI Studio, under the model ID gemini-4-neon, with Batch, Flex and Priority inference all supported. It is not on the free tier. Google's comparison card notes that Neon and Carbon "require the paid API tier," while Hydrogen and Gemini 3.5 Flash-Lite are available free - Google AI Studio.

Vertex AI and business plans. Enterprise access runs through Google Cloud, where OpenRouter's listing (below) shows the global endpoint at the API price and EU in-region routing at 10% more. Google's announcement says Neon is in Gemini for business through the API and the model selector - Google.

OpenRouter. Neon is listed with Google AI Studio and Google Vertex as providers, which makes it easy to test beside other labs' models behind one API key - OpenRouter.

Google Antigravity. Paid Google AI Pro and Ultra subscribers get Neon in Antigravity's desktop app, CLI and IDE extensions, including the planner and executor pairing with Hydrogen, which Google pitches as "stretching your quota further on every run" - Google Antigravity. That phrase is the subscription version of the cost-per-task argument: on a plan with usage limits, a model that does the same work with fewer resources lets you do more work before you hit the limit. Google did not publish quota numbers for Neon in Antigravity. In Gemini's Managed Agents API, the Antigravity agent runs on Hydrogen by default and lets you switch to Neon or Carbon per task - Google AI Studio.

The Gemini app. Neon is available to Google AI Pro and Ultra subscribers in the Gemini app, while Carbon in the app is reserved for Ultra, per the lineup card in Google's announcement - Google. For an individual whose agent work fits inside a subscription's limits, that is the cheapest way to use Neon at all, because the marginal cost per task is zero until the limit.

The cyber variant. A version with the dual-use offensive security capabilities Google reported is rolling out to eligible members of the Fairwind Program over the days after launch, with requests going through a Google Cloud account team - Google.

Rate limits on the paid API depend on your project's usage tier and are shown in AI Studio; Google did not publish Neon-specific figures in its launch material. If you run many agents in parallel, check your active limits before you migrate a production workload, and set your own caps on simultaneous jobs and retries so a burst of failures does not turn into a burst of spend.

13. A Migration and Routing Playbook

Everything above reduces to a short sequence of decisions. Here it is in the order a team would actually make them.

Step 1: measure the shape of your tasks

Before comparing models, log a week of real agent runs and compute, per task, total input tokens, the share that hit the cache, output tokens and turns. The ratio of input to output tells you which side of the crossover in section 6 you are on. Above roughly 12 input tokens per output token with good caching, Neon's rate card is an advantage over Astra; below it, Astra's token frugality is. Against Sol and Hydrogen, Neon is always more expensive per attempt, so the question there is purely whether its higher success rate pays for the difference on your work. If you do not yet log these numbers per task, that is the first thing to fix; our comparison of AI agent observability tools covers the options.

Step 2: migrate off Carbon before December 1

If you run Carbon or Argon today, December 1 doubles your bill. For most workloads Neon at high matches Carbon's index score for under half the cost per task at Carbon's new list price, so the migration is worth doing first. Google says the switch "requires no request schema changes" between Gemini 4 models, but the defaults differ - Google AI Studio. Here is the minimal change, adapted from Google's own example, with the thinking level set explicitly so the comparison is fair:

from google import genai

client = genai.Client()

# Same request shape as Carbon; set model and thinking level explicitly.
interaction = client.interactions.create(
    model="gemini-4-neon",
    input="Find the race condition in the retry queue and propose a fix.",
    generation_config={
        "thinking_level": "medium",  # Carbon's default; Neon uses "high"
        "max_output_tokens": 65536,  # caps thinking + answer together
    },
)

print(interaction.output_text)
print(interaction.usage)  # log input, cached and output tokens per call

Run your evaluation set at medium and high, compare quality and cost per task against Carbon, then pick. If you come from Gemini 3 or earlier, also remove temperature and other sampling parameters, remove explicit cache references, raise any hard-coded low max_output_tokens, declare tools natively rather than asking for JSON in a system prompt, and raise client timeouts to at least 15 minutes, per Google's migration checklist.

Step 3: order prompts for the implicit cache

Because Neon caches implicitly, the only lever you have is prompt order. Put everything that does not change (system instructions, tool definitions, reference documents, the codebase map) at the start, and everything that does (the latest tool result, the user's new message, timestamps) at the end. Make sure the stable prefix exceeds 4,096 tokens, the minimum Google applies caching to. On a long agent loop, this single change is worth more than any choice between models: it is the difference between paying $0.15 and $3 for most of your input.

Step 4: route by step, not by task

The cheapest frontier-quality setup is rarely one model. Google's documentation describes the pattern it recommends: a stronger model designs the approach or isolates a hard bug, then hands the conversation to Hydrogen through previous_interaction_id to "write the code edits, run parallel subagent tasks, and iterate on tests at lower latency and cost" - Google AI Studio. A practical routing map for a Gemini-based agent (an illustration to adapt, not a prescription) might look like this:

The same logic works across labs. Nothing stops an agent from planning on Neon and executing on Sol, or reviewing Neon's output with Fable 5.2 on the few tasks where an error is expensive. Our guide to AI model routing covers how teams build and evaluate routers.

Step 5: send what can wait to Batch or Flex

Evaluations, backfills, nightly reports and any agent run that nobody is waiting on can go through Batch or Flex at half price: $1.50 input and $7.50 output for Neon. On example A from section 8, that brings Neon's cost per attempt from $2.12 to about $1.06, roughly the price of Hydrogen at full rate, without changing the model.

Step 6: put a budget on every agent

Neon's verbosity at xhigh and its occasional failed commands are both ways for a single task to cost ten times its median. Cap output tokens per call, cap turns per task, cap retries, and set a dollar ceiling per task that stops the run and reports instead of continuing. Section 14 shows that the major platforms have started building exactly these controls into their agent products.

Step 7: re-test in a month

Google shipped four Gemini 4 models in seven weeks. OpenAI shipped GPT-6.2 Astra and Sol in the same week as Neon - OpenAI, Anthropic shipped Claude Fable 5.2 on November 9 - Anthropic, and Arena still marks Neon's rating as preliminary. Treat every number in this guide, and every routing decision you make from it, as provisional, and schedule a re-evaluation rather than assuming the choice will hold.

A note on doing all this yourself: everything above assumes you are building and operating the agents. If what you actually want is the outcome (a business that runs, a product that ships) rather than the model plumbing, a platform that builds and operates an autonomous company through AI, such as O-mega, is a different way to approach the same problem, with its own trade-offs in control and flexibility against the work you no longer do.

14. The Market Around Neon: Agents That Spend Money

Neon arrived in a week when AI agents moved from answering to acting, and from acting to spending. That context explains why cost per task, rather than price per token, is becoming the number buyers actually negotiate on.

Agents now buy things

On November 13, OpenAI launched ChatGPT Wallet for ChatGPT Pro subscribers aged 18 and over in the US, starting in its dots agent. The card network supplies a payment token, which OpenAI describes as "a substitute for the user's actual card details," each purchase is approved with "a security check such as Face ID or a fingerprint scan," and the partners are American Express, Chase, Mastercard and Visa - OpenAI. Notably, there are no spending limits at launch; OpenAI says only that they may come later.

Four days later, Google made Tasks in Gemini free "for hundreds of millions of people across the U.S., Japan, Korea, Canada, Australia, and India," running on Gemini 4 Hydrogen, able to call businesses and to check out with a new Google Pay integration, with advanced features starting in the US. Google's design choice is the opposite of OpenAI's on limits: "You can also set a hard spending cap upfront, and Gemini is designed to stay within your budget" - Google.

A day later, Google's Neon announcement added that "Tasks in Gemini can now run on Neon" - Google, so the model in this guide is now one of the engines behind a consumer agent that spends real money.

On November 19, Gemini's computer use came to Apple Silicon Macs running macOS Sequoia 15.0 or later, for personal accounts on US, English-language Plus, Pro and Ultra subscriptions, working in "an isolated background window with a live preview" - Google. It is a further step from an assistant that talks to one that operates software on your behalf, and Google did not say which model powers it.

Persistent agents come with budgets

The same week, the products that run agents continuously added budget controls as a core feature. Replit Missions asks you to "Set your maximum Replit AI usage budget in USD" for each mission, with two candid caveats: work already running "can take AI spending slightly over the budget before it stops," and "the budget does not guarantee that the mission will succeed within that amount" - Replit. Cognition's Devin Bots give each bot "its own budget, measured against the results it delivers," according to Fortune's report on the launch - Fortune. Perplexity's Teammates, agents built for complex ongoing work, launched first on the web for subscribers to its Max plan - Perplexity. Digital Trends puts that plan at $200 a month - Digital Trends.

The enterprise side moved too. At Ignite, Microsoft's Agent 365 added cost management that tracks "consumption across users, services, agents, and models" and lets administrators "Apply spending limits and alerts at the user, group, organization, or resource level," alongside discovery of "more than 60 local AI agents, such as Claude Code and GitHub Copilot CLI" - Microsoft. The tooling layer under all of this is being funded as infrastructure: LangChain raised a $300 million Series C at a $3 billion valuation, saying "more than 7,000 organizations already rely on LangSmith" - LangChain.

Why this changes the model decision

Put these launches next to each other and a structural shift is visible. When an agent ran one prompt for one person, the buyer saw a price per token and a monthly bill. When an agent runs continuously, buys things and is managed against a dollar budget, the buyer sees a cost per completed outcome, and every platform above is building its controls in exactly those units. Replit's own launch example describes a swarm of agents that built dashboards "in two days, within a $3,000 budget" - Replit. A budget like that, or a spending cap on a Gemini task, is a fixed number of outcomes at a given cost per task. A model that finishes the same agent task for $2.52 instead of $5.65 doubles what that budget buys.

That is the market Neon is priced for. It is not the most capable model, and Google does not claim it is. It is a model designed to be close to the most capable at a fraction of the cost per agent task, released into a week when the unit of purchase for agents became the task. The capital flowing into the labs reinforces the point: Anthropic priced its IPO at $83 a share and raised $81.3 billion, which TechCrunch reports as the largest IPO in history by proceeds - TechCrunch, and its shares closed their first day of trading at $97.17 - AP via NBC Washington. Labs with that much capital to deploy compete on capability at the top and on price per outcome everywhere below it. For more on the IPO itself, see our guide to Anthropic's IPO.

15. Outlook and Verdict

What changes in the next few weeks

Three dated events will change the numbers in this guide. On December 1, Carbon and Argon double in price, which moves every Gemini workload still on them by default and makes Neon Google's cheapest route to Carbon-level scores. From November 30 to December 4, AWS holds re:Invent in Las Vegas - AWS, where agent launches from Amazon and its partners will add new competitors and, likely, new price points. And Google has promised the full Neon Safety & Security report "in the coming days," which will put numbers behind the safety claims in section 3.

Beyond the dates, two trends are worth watching. The first is whether OpenAI's token-frugal approach or Google's cheap-per-token approach wins on agent work over the next generation. The arithmetic of section 6 says the answer depends on how input-heavy agents remain, and features that shrink re-sent context (better compaction, fewer redundant reads, server-side conversation state) push the balance toward models that think tersely. The second is how fast the leaderboards themselves settle. Arena's rating for Neon is preliminary, Artificial Analysis's coding index is already on version 2.1 - Artificial Analysis, and every lab now publishes cost-per-task claims for its own models. The independent cost measurements are the most valuable numbers in this market, and the most likely to be gamed.

The verdict

Gemini 4 Neon is the best value at the frontier for agent work as of November 2026, and not the best model. On the three leaderboards built from agent tasks it sits in the top tier (second on Vals, level with Opus 5.5 on Agent Arena, first on the Artificial Analysis Coding Agent Index) at roughly 30% to 55% of the cost per task of Anthropic's flagships, and it finishes faster. On the broadest intelligence index it is third, and GPT-6.2 Astra reaches a higher score for less, because that index rewards terse reasoning and Neon reasons at length.

The practical guidance follows from the cost model rather than the leaderboards:

  • Choose Neon for input-heavy agent loops (coding across a repository, browsing, research that accumulates context) where quality close to the frontier matters and someone is waiting. Run it at high by default and medium for routine turns.
  • Leave Carbon before December 1 unless you have measured that your hardest tasks need it; Neon at high matches its index score for under half the cost at Carbon's new price.
  • Prefer GPT-6.2 Astra or Sol for short, reasoning-heavy work with little input, where their token frugality beats Neon's rate card, and Sol for high-volume routine work where cost dominates.
  • Pay for Claude Fable 5.2 where the hardest tasks fail on everything else and a failure is expensive; it remains the most capable model measured, at several times the cost.
  • Use Hydrogen under Neon for the execution steps of larger jobs, and measure whether the hand-offs eat the savings.

And whichever you choose, measure cost per finished task on your own workload, in your own harness, before believing any number in this guide, including the ones we calculated. The models will change again before the year is out; the method for choosing between them will not.

What this article rests on

Every model figure above is read from its record, re-read from OpenRouter's model feed every 6 hours, so the figures on this page are current even where the prose around them is older. Prices are OpenRouter's listed price per million tokens: for a lab's closed models that is the lab's own list price, and for an open-weight model it is the price of the host OpenRouter routes to by default, which can differ from the lab's own API and from other hosts.

  • Gemini 4 Neon (Google): $3 in and $15 out per million tokens, cached input $0.15, a 1M token window, listed 18 November 2026.
  • GPT-6.2 Astra (OpenAI): $8 in and $40 out per million tokens, cached input $0.40, a 1.05M token window, listed 17 November 2026.
  • GPT-6.2 Sol (OpenAI): $2 in and $10 out per million tokens, cached input $0.10, a 1.05M token window, listed 17 November 2026.
  • Claude Fable 5.2 (Anthropic): $8 in and $40 out per million tokens, cached input $0.20, a 1M token window, listed 9 November 2026.
  • Claude Opus 5.5 (Anthropic): $4 in and $20 out per million tokens, cached input $0.20, a 1M token window, listed 22 September 2026.
  • Claude Sonnet 5.5 (Anthropic): $2 in and $10 out per million tokens, cached input $0.10, a 1M token window, listed 28 September 2026.

In this topic: AI models

Which AI model should your agents run on? Every guide on it