Should you move from Gemini 4 Argon to Neon? A migration plan with a rollback path
Gemini 4 Argon is not deprecated, but Neon is cheaper from December 1 and faster on Artificial Analysis. What changes, how hallucination really compares by thinking level, and a step-by-step migration with eval set, shadow traffic and rollback.
For most Gemini 4 Argon workloads, moving to Gemini 4 Neon is worth planning now, but not as a blind model-ID swap. From December 1, 2026, Argon’s Standard rate doubles to $4/$20 per million tokens while Neon stays at $3/$15, and on Artificial Analysis (AA) Neon at its default high level scores higher than Argon at either of its tested levels in about half the time. Argon has no announced shutdown date, so there is no deadline forcing the move. The thing to watch is that Neon defaults to a deeper thinking level than Argon does. And the low hallucination rate people quote for Argon (4.3%) belongs to Argon high, not to Argon’s API default.
This guide was checked on November 19, 2026 against Google’s Gemini API docs (deprecations, choosing-a-model, the Argon and Neon developer guides and model pages, pricing) and AA’s live model pages. We did not call Neon. We did run a small grounded-answer eval set against Argon through Ofox to show the baseline step of the migration; the results and limits are in step 2. Cost comparisons are labelled as our arithmetic.
Ofox publishes this article. Gemini 4 Argon is available on Ofox as google/gemini-4-argon. Gemini 4 Neon is not available on Ofox (checked against the authenticated model list on November 19, 2026), so any Neon call described here goes to Google’s Gemini API directly. What that means for a migration is covered in its own section below.
Is Gemini 4 Argon being retired?
No retirement has been announced. Several signals point toward Neon as Google’s preferred model, though, and it helps to separate what Google says from what others report.
| Signal | What it says | Source and status |
|---|---|---|
| Deprecations page | gemini-4-argon: released October 13, 2026, “No shutdown date announced”, no recommended replacement listed | Google deprecations page, official, checked Nov 19 |
| Choosing-a-model guide | Recommends Hydrogen, Neon and Carbon (plus 3.5 Flash-Lite). Argon is not mentioned anywhere on the page, including the upgrade-paths table | Choosing a model, official, checked Nov 19 |
| Neon developer guide | Has a section titled “Migrate from Gemini 4 Carbon, Argon, or Hydrogen” | Neon guide, official |
| Argon developer guide | Still published, still recommends medium as the default and Argon as “ideal for most advanced software engineering and knowledge work tasks”; no deprecation note | Argon guide, official, checked Nov 19 |
| Gemini app | Google says Pro and Ultra subscribers can select Neon from the model drop-down | Neon announcement, official |
| Gemini app picker | 9to5Google reports that “Neon also replaces Argon” in the picker, listing Auto, Hydrogen, Neon and Carbon | 9to5Google, Nov 18, 2026, press report, not confirmed by Google |
Our reading: in the API, Argon is a supported GA model with no end date, while Google’s guidance steers new projects to Neon. An app picker change, if the press report is right, does not touch the API endpoint. The deprecations page says shutdown dates come with advance notice, so a monthly check is enough. Access differences between the app, AI Studio and Antigravity are in our Argon access guide.
What changes between Argon and Neon
The request schema is the same. Google’s Neon guide states that switching from another Gemini 4 model “requires no request schema changes.” The differences are in defaults, price and behaviour.
| Gemini 4 Argon | Gemini 4 Neon | |
|---|---|---|
| Model ID | gemini-4-argon | gemini-4-neon |
| GA date | October 13, 2026 | November 18, 2026 |
| Thinking levels | low, medium (default), high | low, medium, high (default), xhigh |
| Context window | 1,048,576 tokens, shared by input, thinking and output | Same |
| Output per response (default) | 65,536 tokens; long decode up to 1M with background execution | Same |
| Foreground continuation hop | 64K streaming, but 32,768 per non-streaming hop | 64K streaming and non-streaming |
| Caching | Implicit only (explicit cachedContents not supported) | Same |
| Built-in tools (model page) | Code execution, computer use, file search, function calling, Search and Maps grounding, structured outputs, URL context | Same list |
| Batch, Flex, Priority | Supported | Supported |
| Free tier | No | No |
| Standard price per 1M (input / cached / output) | $2 / $0.10 / $10 through Nov 30; $4 / $0.20 / $20 from Dec 1 | $3 / $0.15 / $15, no date change |
| On Ofox (Nov 19) | Yes, google/gemini-4-argon | No |
Sources: the Argon and Neon model pages, both developer guides, the long decode guide (hop sizes) and the pricing page, checked November 19, 2026.
Two small documentation differences matter for cleanup. Both guides tell you to remove temperature, top_p and top_k. Argon’s guide says they are ignored if sent; Neon’s says in-range values are ignored and out-of-range values return a 400 validation error. On output caps, Argon’s guide asks for at least 32,768 if you set max_output_tokens, while Neon’s says to remove low caps or raise them to 65,536 and lower the thinking level instead if you want fewer tokens.
Price: when Neon is cheaper
Neon’s token rates are 1.5× Argon’s through November 30 and 0.75× Argon’s from December 1. That gives a simple break-even, which is our arithmetic on Google’s Standard rates:
- Through November 30: Neon costs less only if it uses fewer than 0.67× Argon’s tokens for the same work.
- From December 1: Neon costs less unless it uses more than 1.33× Argon’s tokens.
The catch is the thinking default. An unchanged request runs Argon at medium and Neon at high, so Neon may produce more output tokens per call. Artificial Analysis measured both at several levels on the same harness, which gives a rough sense of the net effect:
| Configuration (AA, Nov 19) | Cost per index task as AA lists it | Our December estimate | Time per index task |
|---|---|---|---|
Argon medium (API default) | $4.31 | ~$8.63 | 29.1 min |
Argon high | $4.97 | ~$9.95 | 29.8 min |
Neon medium | $1.90 | $1.90 | 8.3 min |
Neon high (API default) | $3.74 | $3.74 | 14.8 min |
Neon xhigh | $6.44 | $6.44 | 21.5 min |
AA prices Argon at the current $2/$10 rate. The December column doubles AA’s Argon figure on the assumption that its cost is all token cost; that is our estimate, not an AA number. Neon has no date change. On AA’s task mix, Neon high was already about 13% cheaper per task than Argon medium in November, and the gap widens to about 57% after December 1. AA’s time per task is output tokens divided by measured output speed (AA lists Argon at 57 to 65 tokens/s and Neon at about 101 tokens/s), so it measures generation time, not a full agent run with tool execution.
Aggregate benchmark costs are a direction, not a forecast for your traffic. For the full December change and a monthly bill formula, see what changes for Carbon and Argon on December 1. For per-level Neon budgeting, see our Neon pricing guide, and for Argon’s per-request accounting, the Argon pricing breakdown.
Quality and speed at matched thinking levels
AA runs both models through the same harness, Google’s first-party API, and reports each thinking level separately. The values below come from AA’s Argon and Neon pages, read November 19, 2026. AA lists only medium and high for Argon.
| AA metric | Argon medium | Argon high | Neon medium | Neon high |
|---|---|---|---|---|
| Intelligence Index (v5.0.1) | 47.6 | 50.4 | 54.9 | 59.6 |
| Terminal-Bench 4.0 | 55.1% | 57.1% | 54.5% | 61.6% |
| FrontierCode-AA 2.0 | 25.0% | 25.7% | 36.9% | 43.3% |
| HLE-Diamond | 42.5% | 56.7% | 63.6% | 68.4% |
| CritPt v2 (hard subset) | 53.5% | 52.5% | 61.5% | 59.0% |
| AA-Omniscience accuracy | 49.0% | 48.3% | 57.9% | 59.4% |
Neon medium already matches or beats Argon high on everything except Terminal-Bench 4.0, where they are within three points. On FrontierCode the gap is large at every pairing. These are aggregate scores on AA’s tasks; a model that scores higher overall can still fail one of your prompts that the other passes, which is why the migration plan below starts with your own eval set.
Google’s model cards do not help much here. Argon’s card is dated October 2026 and Neon’s November 2026, they compare against different rival sets, and Google publishes no Argon-vs-Neon table. We did not mix their rows.
The hallucination numbers, read correctly
AA’s Omniscience evaluation defines hallucination rate as incorrect answers divided by all non-correct responses (incorrect + partial + not attempted). It answers: when the model does not know, how often does it guess wrong instead of declining? It is a closed-book knowledge test, and it says nothing about how often the model answers correctly. Reading it alongside accuracy matters.
| Configuration | Hallucination rate | Accuracy | Correct per 100 | Wrong per 100 | Declined or partial per 100 |
|---|---|---|---|---|---|
Argon medium (API default) | 15.4% | 49.0% | 49.0 | 7.9 | 43.1 |
Argon high | 4.3% | 48.3% | 48.3 | 2.2 | 49.5 |
Neon medium | 16.2% | 57.9% | 57.9 | 6.8 | 35.3 |
Neon high (API default) | 13.9% | 59.4% | 59.4 | 5.6 | 35.0 |
Neon xhigh | 14.4% | 60.5% | 60.5 | 5.7 | 33.8 |
Rates and accuracy: AA page data, November 19, 2026. The per-100 columns are our arithmetic: wrong = (100 − accuracy) × hallucination rate.
This changes the usual framing. The widely quoted 4.3% is AA’s headline Argon entry, which AA labels Argon (High). At Argon’s API default, medium, AA measured 15.4%, slightly worse than Neon’s default. So:
- Argon default → Neon default (the common case): on this benchmark, about 10 more correct answers and about 2 fewer wrong answers per 100 questions. Nothing to lose on this measure.
- Argon
high→ Neonhigh: about 11 more correct answers, but about 3.4 more wrong answers per 100. Argonhighdeclines far more often instead of guessing. If you deliberately run Argon athighbecause wrong answers are expensive, this is the one place the migration can make outputs worse, and you need the guardrails in step 5.
Neon’s rate moves much less across levels: 18.8% at low, 13.9% at high, 14.4% at xhigh. Argon’s large swing between medium and high comes from a single AA snapshot, so test your own abstain cases rather than treating either number as fixed. Google’s Neon announcement cites a “lowest fabrication rate yet” from internal Antigravity testing; that is a different measure and cannot be compared with AA’s. Our Gemini 4 hallucination rates comparison covers the whole family and rival models.
Should you move? A decision table
| Your situation | Recommendation |
|---|---|
Argon at default medium for coding, agents or document work, calling Google directly | Migrate to Neon. Evaluate at medium and high; most of the cost gain comes from not over-thinking |
Argon at high for closed-book answers where a wrong answer is worse than none | Stay, or migrate only after the guardrails in step 5 pass your unanswerable-question set |
| Latency-sensitive interactive features | Test Neon medium first; on AA it finished in under a third of Argon’s time |
Argon at low for cheap, high-volume steps | Compare Neon low and Hydrogen instead of Neon high; AA has no Argon low data to compare |
| Traffic routed through Ofox and no Google API project | Stay on Argon for now (Neon not on Ofox), or run the evaluation on Google’s API directly. See the Ofox section |
| A Neon pilot that fails your acceptance checks where Argon passed | Stay on Argon for that task type; there is no shutdown date pushing you |
| Hardest debugging, proofs, research-grade physics | Consider Neon vs Carbon rather than staying on Argon |
The migration, step by step
Step 1: Inventory every Argon call
List each place that sends gemini-4-argon, and record per call site:
- route (Google API, Vertex, Ofox, a framework default);
- API surface (
generateContentor Interactions, streaming or not, background jobs); thinking_levelactually sent (unset meansmediumon Argon);max_output_tokens, tools declared, structured-output schemas, Search grounding;- whether conversation state lives server-side (
previous_interaction_id) or in client-managed history with thought signatures; - monthly input, cached and output tokens, from usage logs.
The unset thinking level is the line that changes behaviour silently. Write it down as medium explicitly before you touch anything else.
Step 2: Build an eval set and record an Argon baseline
Pull 30 to 200 real requests per task type, each with an automatic acceptance check: tests pass, JSON validates, the extracted value matches, or the answer quotes its source verbatim. Include requests whose correct answer is “this isn’t in the material.” Those catch the hallucination shift described above.
To show what this step looks like, we ran a 10-case grounded-answer set against Argon on November 19, 2026. Each request carried a short fictional billing policy and one question. Six questions were answerable; four were not (for example, a refund rule for monthly plans when the policy only covers annual plans). The system instruction told the model to answer only from the document, return NOT_IN_DOC when the answer was missing, and copy a supporting sentence verbatim. Output was constrained with a JSON schema. We graded automatically: answerable cases needed the expected value and a quote that appears character for character in the document; unanswerable cases needed exactly NOT_IN_DOC.
| Argon via Ofox, Nov 19 | medium | high |
|---|---|---|
| Cases passed | 10 / 10 | 10 / 10 |
| Answerable: correct value + verbatim quote | 6 / 6 | 6 / 6 |
Unanswerable: returned NOT_IN_DOC | 4 / 4 | 4 / 4 |
| Mean thinking tokens reported | 0 (field absent) | 164 |
| Total billable output (visible + thinking), 10 calls | 440 | 2,077 |
| Median latency | 5.6 s | 8.2 s |
Route: Ofox’s Gemini-native endpoint, gemini-4-argon, maxOutputTokens 32,768, one run per case per level. “0 thinking tokens” means usageMetadata had no thoughtsTokenCount field. Prompt tokens averaged 542 per call.
Read this for what it is: a baseline on an easy set, n = 10 per level, one day, one route. It does not show Argon is reliable in general, and it says nothing about Neon. Its value is that the file, the grader and the Argon numbers now exist, so the same cases can be pointed at gemini-4-neon on Google’s API and compared line by line. On this set, high cost about 4.7× the billable output of medium for the same 10/10 result, which is the kind of finding that should decide your Neon level too. Your own set should be harder than ours; a set where everything passes cannot detect a regression.
A minimal harness that keeps the request body identical and swaps only the route and model:
import json, os, urllib.request
ROUTES = {
# Argon through Ofox's Gemini-native endpoint (key: OFOX_API_KEY)
"argon": ("https://api.ofox.ai/gemini/v1beta/models/gemini-4-argon:generateContent",
os.environ["OFOX_API_KEY"]),
# Neon through Google's Gemini API (not available on Ofox as of Nov 19, 2026)
"neon": ("https://generativelanguage.googleapis.com/v1beta/models/gemini-4-neon:generateContent",
os.environ["GEMINI_API_KEY"]),
}
def run(route, system, user, level, schema=None):
url, key = ROUTES[route]
cfg = {"thinkingConfig": {"thinkingLevel": level}, "maxOutputTokens": 65536}
if schema:
cfg |= {"responseMimeType": "application/json", "responseSchema": schema}
body = {"systemInstruction": {"parts": [{"text": system}]},
"contents": [{"role": "user", "parts": [{"text": user}]}],
"generationConfig": cfg}
req = urllib.request.Request(url, data=json.dumps(body).encode(),
headers={"x-goog-api-key": key, "Content-Type": "application/json"})
r = json.load(urllib.request.urlopen(req, timeout=900))
parts = r["candidates"][0]["content"]["parts"]
text = "".join(p.get("text", "") for p in parts if not p.get("thought"))
return text, r.get("usageMetadata", {})
Always pass thinkingLevel explicitly in the harness so neither model falls back to its own default. The 900-second timeout follows Google’s advice of at least 15 minutes for hard prompts. Ofox’s native-protocol request format is documented in the Ofox Gemini API reference.
Step 3: Map the parameters
| Argon setting today | Neon starting point | Notes |
|---|---|---|
thinking_level unset (= medium) | Test medium and high; pin the winner explicitly | Leaving it unset moves you to high |
medium set explicitly | medium, then high if checks fail | AA: Neon medium scores above Argon high |
high | high; xhigh only for cases high fails | xhigh raised AA cost per task by 72% over high |
low | low, and compare Hydrogen | Neon low scored 44 on AA’s index |
max_output_tokens below 32,768 | 65,536 or unset | Thinking shares the cap with the answer |
temperature / top_p / top_k | Remove | Out-of-range values return 400 on Neon |
cached_content references | Already removed for Argon; nothing to change | Both use implicit caching on prompts of at least 4,096 tokens |
| Background jobs over 64K | Unchanged | Same 64K hop and 1M ceiling |
| Foreground non-streaming continuation (REST loop) | Expect fewer, larger hops | Argon hops at 32,768, Neon at 65,536; recheck any code that counts hops or sizes timeouts per hop |
| Client timeout | At least 15 minutes, or background execution | Same advice in both guides |
If you use the Antigravity agent in Gemini Managed Agents, the change is the model field in agent_config. Both models are supported there.
Step 4: Shadow the traffic
Send a copy of a sample of live Argon requests to Neon, return only Argon’s answer to users, and log both. Rules that keep the comparison fair:
- Keep the prompt, tools and documents byte-identical, and pin the thinking level on both sides.
- Start with stateless requests. For multi-turn sessions, Google says to return prior model turns and thought signatures unchanged when switching models across turns. We have not tested moving an in-flight session between Argon on one route and Neon on another project, so let existing sessions finish on Argon and start new sessions on Neon.
- Score both outputs with the same automatic checks from step 2, plus a sampled human review of disagreements.
- Watch tool-calling paths separately. If Neon returns
MALFORMED_FUNCTION_CALLor a missing-thought-signature error, the cause is usually how tools or history are sent; our thought-signature fix and the Gemini 4 API error guide cover both. - Remember that shadowing doubles your token spend for the sampled share. A 5 to 10% sample is usually enough.
A new Google Cloud project for Neon brings one data-handling default worth checking: since October 26, 2026, new paid-tier projects using generateContent store requests by default (store=true), according to Google’s release notes. Set store=false per request or change the logging setting if that conflicts with your policy.
Step 5: Add guardrails for wrong answers
If your Argon workload relies on abstaining, especially at high, add checks that do not depend on the model’s own restraint:
- Verbatim citation check. Require a supporting quote and reject answers whose quote is not a substring of the source, as our grader does. This catches invented support cheaply.
- Explicit abstain token. Give the model a fixed value such as
NOT_IN_DOCand treat anything else on your unanswerable set as a failure. - Structured output. Use
responseSchemarather than asking for JSON in prose; Neon’s guide warns that raw-text JSON tool calls with no declared tools can returnMALFORMED_FUNCTION_CALL. - Grounding where facts are external. Use Search grounding or your own retrieval for open-world questions, and note that Search grounding is billed per query on top of tokens.
- Gate metric. Make “wrong answers on the unanswerable set” a release gate, not just “accuracy on the answerable set.” Hold Neon to Argon’s baseline on that line.
Step 6: Monitor cost per accepted task
Log promptTokenCount, cachedContentTokenCount, candidatesTokenCount and thoughtsTokenCount per request, and compute cost with the model’s own rates:
cost = (prompt - cached) × input_rate / 1e6
+ cached × cached_rate / 1e6
+ (candidates + thoughts) × output_rate / 1e6
Divide total cost by the number of requests that passed their check, not by all requests; retries are where a cheaper per-token model can lose. Alert when Neon’s billable output per request exceeds 1.33× Argon’s for the same task type, the December break-even above. If you keep Argon traffic on Ofox, per-request token and cost breakdowns for that side appear in Ofox’s usage tracking.
Step 7: Cut over gradually and keep the rollback path
Move one task type at a time behind a flag: 10%, then 50%, then 100%, with a few days at each stage. Keep the Argon configuration (model ID, pinned thinking level, route) intact rather than deleting it. Roll back a task type when any of these trips:
- pass rate on the live check drops below the Argon baseline by more than your agreed margin;
- wrong answers on the unanswerable set exceed the Argon baseline;
- cost per accepted task rises above Argon’s at the rate in force;
- p95 latency or timeout rate breaches your SLO;
429or quota errors appear on the new project. Neon’s limits are per Google project and tier, so check them before 100%. Our Argon API error guide and the general 429 retry guide cover backoff.
The fallback lasts only as long as Argon does, so check the deprecations page before each release.
What Ofox users can and cannot do today
As of November 19, 2026:
- You can keep calling Argon through Ofox as
google/gemini-4-argon, through either the OpenAI-compatible or the Gemini-native protocol listed on its model page. The price Ofox charges is on that page; we do not restate it here, and you should check it again after December 1. - You cannot migrate to Neon inside Ofox. Neon is not in the catalog, so there is no single-key A/B test, and changing the model string on an Ofox request to
gemini-4-neonwill not reach Neon. - To evaluate or run Neon now, you need a paid-tier Google Gemini API project and key, separate billing and separate rate limits. The harness in step 2 shows the two routes side by side. Our Neon API guide walks through the native setup.
- Hydrogen is on Ofox as
google/gemini-4-hydrogen, if part of your Argon traffic can move down a tier instead of sideways.
If Neon is added to Ofox later, the migration plan does not change: only the Neon route in your harness does. Error handling for the Ofox side is described in the error-handling guide, and default limits in the rate limits guide.
When staying on Argon is the right call
Most reasons to stay are already in the decision table: your eval shows Neon failing a task type Argon passes, you depend on Argon high abstaining on closed-book questions and cannot add citation checks yet, or all your traffic runs through Ofox. Two more are about timing. Finish any long agent session or background job on Argon rather than switching mid-run. And if it is still November and your checks are not done, there is no reason to hurry: Argon is cheaper per token until November 30, and the arithmetic flips on December 1.
What does not justify staying is the idea that Argon is safer by default. At the API default, AA’s measurements put Argon’s hallucination rate slightly above Neon’s, with lower accuracy. To compare levels before pinning one, see our Gemini 4 thinking levels guide.


