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.

A line drawing of a stone irrigation channel splitting in two at a wooden sluice gate: the original channel stays open and carries most of the water, while a small orange-handled gate lets a thin stream into a newly dug second channel.

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.

SignalWhat it saysSource and status
Deprecations pagegemini-4-argon: released October 13, 2026, “No shutdown date announced”, no recommended replacement listedGoogle deprecations page, official, checked Nov 19
Choosing-a-model guideRecommends Hydrogen, Neon and Carbon (plus 3.5 Flash-Lite). Argon is not mentioned anywhere on the page, including the upgrade-paths tableChoosing a model, official, checked Nov 19
Neon developer guideHas a section titled “Migrate from Gemini 4 Carbon, Argon, or Hydrogen”Neon guide, official
Argon developer guideStill published, still recommends medium as the default and Argon as “ideal for most advanced software engineering and knowledge work tasks”; no deprecation noteArgon guide, official, checked Nov 19
Gemini appGoogle says Pro and Ultra subscribers can select Neon from the model drop-downNeon announcement, official
Gemini app picker9to5Google reports that “Neon also replaces Argon” in the picker, listing Auto, Hydrogen, Neon and Carbon9to5Google, 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 ArgonGemini 4 Neon
Model IDgemini-4-argongemini-4-neon
GA dateOctober 13, 2026November 18, 2026
Thinking levelslow, medium (default), highlow, medium, high (default), xhigh
Context window1,048,576 tokens, shared by input, thinking and outputSame
Output per response (default)65,536 tokens; long decode up to 1M with background executionSame
Foreground continuation hop64K streaming, but 32,768 per non-streaming hop64K streaming and non-streaming
CachingImplicit 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 contextSame list
Batch, Flex, PrioritySupportedSupported
Free tierNoNo
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-argonNo

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 itOur December estimateTime per index task
Argon medium (API default)$4.31~$8.6329.1 min
Argon high$4.97~$9.9529.8 min
Neon medium$1.90$1.908.3 min
Neon high (API default)$3.74$3.7414.8 min
Neon xhigh$6.44$6.4421.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 metricArgon mediumArgon highNeon mediumNeon high
Intelligence Index (v5.0.1)47.650.454.959.6
Terminal-Bench 4.055.1%57.1%54.5%61.6%
FrontierCode-AA 2.025.0%25.7%36.9%43.3%
HLE-Diamond42.5%56.7%63.6%68.4%
CritPt v2 (hard subset)53.5%52.5%61.5%59.0%
AA-Omniscience accuracy49.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.

ConfigurationHallucination rateAccuracyCorrect per 100Wrong per 100Declined or partial per 100
Argon medium (API default)15.4%49.0%49.07.943.1
Argon high4.3%48.3%48.32.249.5
Neon medium16.2%57.9%57.96.835.3
Neon high (API default)13.9%59.4%59.45.635.0
Neon xhigh14.4%60.5%60.55.733.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 → Neon high: about 11 more correct answers, but about 3.4 more wrong answers per 100. Argon high declines far more often instead of guessing. If you deliberately run Argon at high because 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 situationRecommendation
Argon at default medium for coding, agents or document work, calling Google directlyMigrate 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 noneStay, or migrate only after the guardrails in step 5 pass your unanswerable-question set
Latency-sensitive interactive featuresTest Neon medium first; on AA it finished in under a third of Argon’s time
Argon at low for cheap, high-volume stepsCompare Neon low and Hydrogen instead of Neon high; AA has no Argon low data to compare
Traffic routed through Ofox and no Google API projectStay 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 passedStay on Argon for that task type; there is no shutdown date pushing you
Hardest debugging, proofs, research-grade physicsConsider 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 (generateContent or Interactions, streaming or not, background jobs);
  • thinking_level actually sent (unset means medium on 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 19mediumhigh
Cases passed10 / 1010 / 10
Answerable: correct value + verbatim quote6 / 66 / 6
Unanswerable: returned NOT_IN_DOC4 / 44 / 4
Mean thinking tokens reported0 (field absent)164
Total billable output (visible + thinking), 10 calls4402,077
Median latency5.6 s8.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 todayNeon starting pointNotes
thinking_level unset (= medium)Test medium and high; pin the winner explicitlyLeaving it unset moves you to high
medium set explicitlymedium, then high if checks failAA: Neon medium scores above Argon high
highhigh; xhigh only for cases high failsxhigh raised AA cost per task by 72% over high
lowlow, and compare HydrogenNeon low scored 44 on AA’s index
max_output_tokens below 32,76865,536 or unsetThinking shares the cap with the answer
temperature / top_p / top_kRemoveOut-of-range values return 400 on Neon
cached_content referencesAlready removed for Argon; nothing to changeBoth use implicit caching on prompts of at least 4,096 tokens
Background jobs over 64KUnchangedSame 64K hop and 1M ceiling
Foreground non-streaming continuation (REST loop)Expect fewer, larger hopsArgon hops at 32,768, Neon at 65,536; recheck any code that counts hops or sizes timeouts per hop
Client timeoutAt least 15 minutes, or background executionSame 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:

  1. Keep the prompt, tools and documents byte-identical, and pin the thinking level on both sides.
  2. 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.
  3. Score both outputs with the same automatic checks from step 2, plus a sampled human review of disagreements.
  4. Watch tool-calling paths separately. If Neon returns MALFORMED_FUNCTION_CALL or 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.
  5. 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_DOC and treat anything else on your unanswerable set as a failure.
  • Structured output. Use responseSchema rather than asking for JSON in prose; Neon’s guide warns that raw-text JSON tool calls with no declared tools can return MALFORMED_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;
  • 429 or 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-neon will 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.