Gemini 4 Neon vs Carbon: which one should you use, and when does Neon get cheaper?

Gemini 4 Neon vs Carbon by task: positioning, November and December token prices, default thinking levels, benchmark rows, hallucination rates, access and worked cost math.

A line-drawn green mountain with two trails from one trailhead: a short switchback to a ledge marked by an orange flag, and a longer winding trail to the summit marked by a blue flag.

Use Gemini 4 Neon as the default for complex coding, agent and document work, and keep Gemini 4 Carbon for the problems where Neon’s answer still fails your acceptance check: deep root-cause debugging, physics-heavy or research-grade reasoning, and very long-horizon agent runs. Through November 30, 2026 Carbon’s per-token price ($2/$10) is lower than Neon’s ($3/$15); from December 1 Carbon moves to $4/$20 and Neon becomes the cheaper model per token. Per-token price is only half of it. At their default settings, Artificial Analysis measured Neon finishing its index tasks in about half of Carbon’s time with a similar score.

This comparison was checked on November 19, 2026, one day after Neon launched. It is based on Google’s documentation, both model cards and their evaluation-methodology PDFs, and Artificial Analysis (AA) data read from its live model pages on the same date. We did not run Neon or Carbon ourselves for this article. The cost scenarios below are labelled arithmetic, not invoices or measurements.

Ofox publishes this article. Neither model is available through Ofox: a GET https://api.ofox.io/v1/models check on November 19 listed google/gemini-4-hydrogen and google/gemini-4-argon, but no Neon or Carbon. Everything below about calling Neon or Carbon refers to Google’s own Gemini API, AI Studio, Gemini app and Antigravity.

How Google positions Neon and Carbon

Google describes the Gemini 4 family as a ladder. In the Neon developer guide, Neon “sits between Gemini 4 Hydrogen and Gemini 4 Carbon for high-frequency complex tasks.” The model selection page adds that Neon “finishes faster with fewer output tokens than Carbon” and is the choice when “you don’t need Carbon’s extra verification.” Carbon is described as Google’s strongest reasoning model, spending more thinking tokens per turn to test hypotheses and check fixes. Google recommends it for system architecture, multi-file debugging, dense multimodal analysis, formal proofs and security audits, “or when a faster model gets stuck.”

The Neon model card states that Neon is adapted from Gemini 4 Carbon and summarizes the split in one sentence: Carbon “tackles your hardest, long-horizon projects,” Hydrogen handles fast everyday execution, and Neon “balances depth and efficiency.” The Carbon model card notes that Carbon may show “occasional slowness or timeout issues” and may use more tokens, especially at higher thinking levels.

The shared technical surface is the same: both use a unified 1,048,576-token window for input, thinking and output, a 65,536-token synchronous output default with long decode up to 1M via background execution or continuation, implicit caching only (no cachedContents), and the same built-in tools (Google Search, code execution, function calling, Computer Use, structured outputs). Because the request schema is identical, switching between them is a model-ID change plus a thinking-level decision. You are choosing between two depths of reasoning, not two APIs.

Gemini 4 NeonGemini 4 Carbon
Model IDgemini-4-neongemini-4-carbon
Model card publishedNovember 18, 2026November 10, 2026
Google’s role for itComplex, high-frequency coding, knowledge and science workHardest, long-horizon problems; when a faster model gets stuck
Thinking levelslow, medium, high (default), xhighlow, medium (default), high
Free API tierNoNo
Knowledge cutoff (model card)March 2026March 2026
On Ofox (checked Nov 19)NoNo

Price per token now and after December 1

These are Google’s Standard paid-tier rates in USD per 1M tokens from the pricing page, checked November 19, 2026. Output includes thinking tokens. Batch, Flex and Priority tiers are not covered here.

Billable itemNeonCarbon through Nov 30, 2026Carbon from Dec 1, 2026
Input$3.00$2.00$4.00
Cached input (implicit cache hits)$0.15$0.10$0.20
Output including thinking$15.00$10.00$20.00

Google states that Neon has no introductory price. Carbon’s November rate is introductory. Every Carbon token rate is exactly two-thirds of Neon’s in November and four-thirds of Neon’s from December 1. That gives a simple rule for identical token usage:

  • November: Carbon costs 33% less than Neon for the same tokens. Carbon stays cheaper unless it consumes more than 1.5× Neon’s tokens on the same task.
  • From December 1: Carbon costs 33% more than Neon for the same tokens. Carbon is cheaper only if it consumes less than 0.75× Neon’s tokens.

The catch is that the same task rarely costs both models the same number of tokens. That is where defaults matter. For per-level Neon budgeting, see our Neon pricing guide by thinking level. For the Carbon and Argon change itself, see what changes on December 1.

Default thinking levels make default-vs-default comparisons uneven

Neon defaults to high and adds xhigh. Carbon defaults to medium and tops out at high. Google’s migration checklist says it directly: “Carbon and Argon default to medium and cap at high.” If you swap the model ID and nothing else, you are comparing Neon at its second-highest level with Carbon at its middle level. Equal setting names also do not guarantee equal compute between two models. Our Gemini 4 thinking levels guide lists which levels each model accepts and how to pick one.

Artificial Analysis evaluates each thinking level separately, which lets us line them up. The values below come from the live Neon and Carbon pages, read on November 19, 2026 (Intelligence Index v5.0.1, Google’s first-party API).

ConfigurationAA Intelligence IndexTime per index taskCost per index task (as AA lists it)Output tokens across the index run
Neon xhigh6121.5 min$6.44283M
Neon high (default)6014.8 min$3.74123M
Neon medium558.3 min$1.9062.9M
Neon low443.7 min$0.7528.3M
Carbon high6037.2 min$7.76205M
Carbon medium (default)5829.6 min$6.59124M
Carbon low5430.4 min$7.1983.9M

Three things to read carefully in that table.

AA prices Carbon at $4/$20. Its Carbon page lists “$4.00 per 1M input tokens” and “$20.00 per 1M output tokens,” which is the December rate, not the November introductory rate. Every Carbon cost figure above is therefore a post-December-1 cost. Because all Carbon token rates are exactly half in November, our estimate of the same runs at November rates is about $3.88 (high), $3.29 (medium) and $3.59 (low) per task. That halving is our arithmetic on AA’s figures, not an AA number.

Time per task is a token-throughput metric. AA calculates it from output tokens per task divided by measured output speed, weighted by index composition. Its pages list Neon at roughly 97–110 output tokens/s across levels and Carbon at roughly 47–58 tokens/s. It is a good proxy for how long a model spends generating, not a wall-clock agent run that includes tool execution.

Google’s “32% lower cost per task” claim does not reproduce from today’s AA page. The Neon announcement ties the figure to the Artificial Analysis Intelligence Index: at its default high level, Neon “pairs a high Artificial Analysis Intelligence Index score with a 32% lower cost per task than Carbon.” What Google left unstated is which Carbon thinking level, which Carbon price period and which AA data snapshot it used. With AA’s current figures, Neon high ($3.74) is 52% below Carbon high, 43% below Carbon medium and 48% below Carbon low at December prices. At November prices it is 3.5% below Carbon high and about 14% above Carbon medium. None of these combinations gives 32%, so treat it as Google’s claim rather than a number you can recompute today.

On this evidence, the like-for-like comparison is Neon high vs Carbon high: near-identical index scores (59.6 vs 60.0), Neon finishing in about 40% of Carbon’s time, and Neon about half the cost per task once December prices apply. Neon high vs Carbon medium (the defaults) gives Neon a slightly higher index score (59.6 vs 58.3) in half the time. One reversal is easy to miss: Carbon low (54) scores far above Neon low (44), though AA measured Carbon low as no faster than Carbon medium.

Benchmark rows where both models appear

Google publishes separate cards, with different comparison sets. The Neon card compares against Claude Opus 5.5 and GPT-6.2 Sol, while the Carbon card compares against Gemini 4 Argon, GPT-6 Astra, Claude Opus 5.5 and Claude Fable 5.1. Neither card has a Carbon-vs-Neon table. The rows below appear on both cards. Before reading them, note the following setup details from Google’s two evaluation-methodology PDFs:

  • Both say results use “the highest thinking settings unless indicated otherwise.” That means Neon xhigh and Carbon high, not the defaults.
  • Carbon’s card is dated “as of October 2026,” and Neon’s is “as of November, 2026.”
  • Carbon’s cybersecurity rows reflect access through the Fairwind Program.
Benchmark (as labelled)Neon cardCarbon cardSame setup?
Vals Index v2.270.9%70.4%Both sourced from Vals AI
AutomationBench (Zapier)56.3%53.9%Both from the public leaderboard (Carbon: private set)
Chartography73.5%72.5%Both without tools
RiemannBench84.0%80.0%Both from the public leaderboard
GraphWalks 256k–1M, BFS F195.2%96.2%Both self-computed on the same 200 problems
SEC-bench Pro90.5%88.2%Same 183-task split and Antigravity harness; Carbon’s score is its Fairwind-access result
Agents’ Last Exam v1.175.8%77.4%No: Neon used the Antigravity-CLI 1.4.8 harness, Carbon the ALE-Claw harness
Terminal-Bench-Science 0.170.5%64.8%No: Neon self-computed over 5 attempts with a mini-swe-agent vision harness; Carbon sourced from AA
SWE-sweep12.8% (mini-SWE) / 39.0% (Antigravity harness)9.6%Only the mini-SWE figures are close in setup (Neon used a “vision” variant)
AA Index61 (v5.0.1)59 (v5.0)No: different index versions. On today’s v5.0.1, Carbon high is 60

Rows that only look alike have been left out: Terminal-Bench 4.1 (Neon) vs 4.0 (Carbon), CWE-bench v2 vs CWE-bench v1, and ExploitGym (Neon’s card has no score). Vending-Bench 2 appears only in the Neon announcement ($16,843) and on the Carbon card ($16,484).

The clean rows support a modest conclusion. Neon matches or slightly exceeds Carbon at their highest settings on several knowledge-work and math tasks. Carbon keeps a one-point edge on 256K–1M-token graph traversal. No row shows a large gap in either direction once harness differences are removed. The SWE-sweep jump from 12.8% to 39.0% for Neon reflects the Antigravity harness, which Google says includes a sub-agent fan-out tool. It is not a model-only gain over Carbon’s 9.6%.

The same rows on Artificial Analysis, per thinking level

AA runs both models through the same harness, so its component scores give a cleaner same-level view. These values come from the same November 19 page data:

AA componentNeon highNeon xhighCarbon mediumCarbon high
Terminal-Bench 4.061.6%63.6%60.6%65.2%
FrontierCode-AA 2.043.3%44.4%39.5%40.6%
HLE-Diamond68.4%71.3%67.4%69.1%
Terminal-Bench-Science 0.165.7%70.0%62.4%64.8%
CritPt v2 (hard subset)59.0%60.5%69.0%69.0%

CritPt, a research-level physics evaluation, is the one place where Carbon leads clearly at every level shown. Terminal-Bench 4.0 favors Carbon high by a small margin. At each model’s top level (Neon xhigh vs Carbon high), Neon leads FrontierCode-AA by 3.8 points, HLE-Diamond by 2.2 and Terminal-Bench-Science by 5.2. At high vs high those margins shrink to 2.7, −0.7 and 0.9, so HLE-Diamond tips to Carbon. Which pairing you compare changes the answer. A two- or three-point gap on a single benchmark is not proof that one model is better at your task.

Hallucination rate: the defaults point in opposite directions

AA’s Omniscience evaluation defines the hallucination rate as the share of incorrect answers among all non-correct responses. In other words, when the model does not know, how often it guesses wrong instead of declining or giving a partial answer. Lower is better. It measures something different from accuracy, so both columns matter:

ConfigurationAA-Omniscience hallucination rateAA-Omniscience accuracy
Neon xhigh14.4%60.5%
Neon high (default)13.9%59.4%
Neon medium16.2%57.9%
Neon low18.8%56.6%
Carbon high11.4%58.3%
Carbon medium (default)4.2%48.9%
Carbon low19.8%49.2%

Source: AA model-page data read November 19, 2026; values rounded to one decimal.

At default settings, Carbon is far less likely to make something up (4.2% against 13.9%), but it also answers correctly much less often (48.9% against 59.4%). Carbon medium declines more often instead of guessing. At high vs high, the gap narrows to 11.4% against 13.9%, with similar accuracy. That makes Carbon medium the better default when a wrong answer costs more than no answer: compliance extraction, citation-bound research summaries, or medical and legal triage where a human reviews the gaps. Neon high is better when coverage matters and you validate the output anyway.

One caution on that 4.2%: Carbon’s rate is not monotonic across levels (19.8% at low, 4.2% at medium, 11.4% at high), while Neon’s falls steadily as thinking rises. This is a single AA snapshot, so treat Carbon medium’s low rate as a reason to test it on your own abstain-or-answer cases, not as a settled property.

Google’s own Neon announcement cites a different measure: its “lowest fabrication rate yet in internal Google Antigravity testing.” That is an internal agentic evaluation, not AA-Omniscience, and the two numbers should not be compared directly.

Where Carbon still earns its place

Google’s documents and the third-party data agree on a short list:

  1. Problems a faster model has already failed. Google’s selection guide says to choose Carbon “when a faster model gets stuck.” That is an escalation rule, not a starting point.
  2. Research-grade physics and proof-style reasoning. CritPt is the clearest measured Carbon lead (69% vs 59–60.5%). Google lists formal proofs and scientific discovery under Carbon.
  3. Very long contexts that require tracing structure. GraphWalks at 256K–1M tokens is 96.2% vs 95.2%. The gap is small, but it is the one long-context row in Carbon’s favor.
  4. Abstain-rather-than-guess workloads, at Carbon’s default medium, for the hallucination reasons above.
  5. Carbon-specific cyber access. Carbon’s cyber results are delivered through Fairwind today. Google says Neon for cyber is “rolling out to trusted defenders in the coming days,” so verified defenders may get both soon.

Neon also has a counter-claim on some of Carbon’s ground. Google says Neon for cyber produced more secure code than Carbon on AutoBaxBench, used half Carbon’s tokens on ExploitGym, and showed “a 3.4% uplift over Carbon” on CWE-bench v2. These are Google’s own statements without a published Carbon figure for the same configuration.

Access: who can use which model where

SurfaceNeonCarbon
Gemini APIPaid tier only (generateContent and Interactions API)Paid tier only
Google AI StudioAvailable; Google AI Pro and Ultra plans can try itAvailable
Gemini app (consumer)Google AI Pro and Ultra subscribersModel card lists Google AI Ultra for consumer surfaces
Google AntigravityPaid Google AI Pro and Ultra subscribersModel card lists Google AI Ultra
Gemini for businessAPI and model drop-downListed
Gemini Managed Agents (Antigravity agent)Supported, standalone or orchestrating HydrogenSupported via agent_config model override
Fairwind cyber variant”Neon for cyber” rolling out to eligible membersCyber capabilities via Fairwind
Ofox API (checked Nov 19)Not availableNot available

Sources: the Neon announcement, both model cards’ distribution sections, the Neon and Carbon developer guides, and the model selection page.

A Google AI Pro subscription therefore reaches Neon in the app and in Antigravity, while the Carbon card lists Ultra for those surfaces. A consumer subscription does not grant API access to either. Your API project must be on the paid tier. If you are deciding which surface to use for a coding agent, our Gemini 4 model selection guide explains how app, Antigravity and API access differ. For a first Neon API request, see the Neon API guide.

Worked cost arithmetic for three workloads

Everything in this section is arithmetic, not measurement. The token quantities are invented to represent common shapes of work. Rates are Google’s Standard USD rates per 1M tokens listed above. Output includes thinking. The calculation script and output are reproducible.

The formula for each request is:

cost = (input_total - cached_input) × input_rate / 1e6
     + cached_input × cached_rate / 1e6
     + output_including_thinking × output_rate / 1e6

The three workloads, using the token counts we assume for Neon high:

  • W1, single document extraction: 80,000 uncached input tokens, 8,000 output tokens.
  • W2, multi-turn coding-agent session: 1,200,000 input tokens across turns, of which 1,000,000 are implicit-cache hits; 90,000 output tokens.
  • W3, long analytical report: 300,000 uncached input tokens, 150,000 output tokens.

Scenario A: identical token usage on both models

WorkloadNeonCarbon, NovemberCarbon, December
W1 document extraction$0.360$0.240$0.480
W2 coding-agent session$2.100$1.400$2.800
W3 long report$3.150$2.100$4.200

W2 is calculated as 0.2M × $3 + 1.0M × $0.15 + 0.09M × $15 = $2.10 for Neon, and 0.2M × $2 + 1.0M × $0.10 + 0.09M × $10 = $1.40 for Carbon in November. This isolates price only: in November Carbon is cheaper for the same tokens, and from December it is more expensive.

Scenario B: Carbon uses tokens in the ratio AA observed

On AA’s full index run, Carbon medium produced 1.01× Neon high’s output tokens and processed 1.47× its input tokens. Carbon high produced 1.66× the output and 1.74× the input. We applied the output ratio to all three workloads. We applied the input ratio only to W2, because a single extraction or report reads the same documents regardless of model, while an agent loop adds turns. This uses AA’s mix of tasks as a stand-in for yours, so treat it as illustration rather than prediction. The ratios are raw run totals; AA’s index-weighted output tokens per task give higher Carbon ratios (1.14× for medium, 1.36× for high), and we show that sensitivity below the table.

WorkloadNeon highCarbon medium, NovCarbon medium, DecCarbon high, NovCarbon high, Dec
W1 document extraction$0.360$0.241$0.481$0.293$0.586
W2 coding-agent session$2.100$1.642$3.284$2.366$4.732
W3 long report$3.150$2.112$4.223$3.096$6.192

The pattern holds across all three shapes. Through November 30, Carbon at its default is the cheaper model even after accounting for heavier token use. From December 1, Neon is cheaper in every case, by 25% to 56% in this scenario. Carbon high in November lands within about 20% of Neon in either direction (cheaper on W1 and W3, dearer on W2) while taking longer, so cost alone is not a reason to pick it.

Sensitivity check: using AA’s per-task output ratios instead, Carbon medium in November comes to $0.251, $1.763 and $2.313 for W1–W3, and Carbon high to $0.269, $2.093 and $2.642. The November conclusion does not change (Carbon high on W2 becomes roughly equal to Neon rather than dearer), and every December Carbon figure rises further above Neon’s.

Two cautions. First, a retry costs more than the token-rate difference. If Neon fails a task that Carbon would pass, the cost per accepted task can reverse, which is why our Carbon task-cost guide counts every attempt, not just the successful one. Second, a request that spans the November 30 to December 1 boundary is billed according to Google’s effective-date treatment, which we have not verified. Do not assume a long background job keeps the introductory rate.

Decision table by task

TaskStart withEscalate toWhy
Multi-file refactor or feature with testsNeon highCarbon high if tests still fail after the context is completeNear-equal index score at high (59.6 vs 60.0); Neon is faster and, from December, cheaper
Intermittent concurrency or cross-service bugNeon highCarbon highGoogle names root-cause debugging as Carbon work; escalation is cheap to test
Agent with many tool calls, long sessionNeon highCarbon only for the planning or review stepGoogle pitches Neon for long tool-heavy runs; Carbon’s slower decode compounds over turns
Research-level physics, proofsCarbon high—Clearest measured Carbon lead (CritPt)
Extraction where a wrong value is worse than a blankCarbon medium—4.2% AA hallucination rate at default, at the cost of lower accuracy; verify on your own cases
Dense PDF, spreadsheet and chart synthesisNeon highCarbon medium if unsupported claims are the failureClose on Chartography; choose on error type
Retrieval over 256K–1M tokens of structured contextEither; test both—95.2% vs 96.2% GraphWalks is within noise for most uses
High-volume, latency-sensitive stepsNeon medium, or Hydrogen—Neon medium scores 55 in 8.3 min on AA; Carbon low was not faster than Carbon medium there
Security review for verified defendersWhichever Fairwind variant you have access toCompare both if you have bothGoogle claims Neon gains over Carbon on several cyber rows

The table is our editorial recommendation from the evidence above, not a guarantee for your workload. Through November 30, Carbon medium is also a reasonable cost-saving default for batch work that tolerates latency. Plan that route to end, or be re-evaluated, on December 1.

Run your own comparison before switching

A fair internal test uses each model at more than one level:

  1. Fix the inputs: same repository commit, documents, tools and acceptance check for every run.
  2. Run Neon at high and medium, and Carbon at medium and high. Add Neon xhigh only if high fails. Set max_output_tokens to at least 65,536 on both. Carbon’s guide recommends no less than 32,768, because thinking can consume a smaller cap before the answer appears.
  3. Record model ID, thinking level, input, cached and output tokens, wall-clock time, retries and whether the result passed.
  4. Price the recorded tokens at both the November and December Carbon rates.
  5. Choose the cheapest configuration that passes, per task type, not one model for everything.

Hard prompts can run for minutes on both models. Google’s Neon guide recommends background execution or HTTP timeouts of at least 15 minutes. If a tool-calling run fails after a model switch, check thought-signature handling before blaming the model. The request and quota errors in our Gemini 4 API error guide (written for Argon) apply to the same API family. For rate-limit retries in general, see when to retry a 429.

What you can use on Ofox today

Since Neon and Carbon are not in the Ofox catalog as of November 19, 2026, the Gemini 4 models you can call through Ofox are Gemini 4 Hydrogen and Gemini 4 Argon, with current prices on those model pages. Hydrogen is Google’s recommended everyday execution model and the one Google pairs with Neon or Carbon as a sub-agent. The Ofox Gemini API documentation covers the native Gemini route, and the error-handling guide covers retries. This article will be updated if Neon or Carbon is added. Until then, use Google’s API for both, and do not treat Google’s rates as Ofox prices.