Language Models

Google Ships Gemini 4 Neon: Its Mid-Tier Model Just Beat Its Own Flagship — But for the Next 12 Days It Costs More Per Token

November 19, 20260 views阅读中文原文
Google Ships Gemini 4 Neon: Its Mid-Tier Model Just Beat Its Own Flagship — But for the Next 12 Days It Costs More Per Token

TL;DR: what actually launched

On November 18, 2026, Google DeepMind released Gemini 4 Neon. Per the official blog, it occupies the middle rung of the Gemini 4 family: deeper reasoning than Hydrogen, faster and cheaper than Carbon, built for high-frequency work that still isn't easy — multi-file code changes, turning piles of reports into a conclusion, and long-running agent tasks.

Three numbers that matter:

  • $3 per million input tokens, $15 per million output tokens, with cached input at $0.15 (a 95% discount)
  • 1 million token context, flat-priced across the entire window with no long-context surcharge
  • A score of 61 on Artificial Analysis's Intelligence Index at the xhigh thinking level, third overall

That 61 is the real news. Google's own flagship, Gemini 4 Carbon, scores 60 on the same index. A model positioned as the fast-and-cheap middle tier has edged past the company's most expensive model on an independent leaderboard. Only two models sit above it: GPT-6.2 Astra at 62 and Claude Fable 5.2 at 65.

Why this one is different

For the past year Google's lineup had a clean division of labor: Hydrogen for quick everyday answers, Carbon for the hardest work, and nothing in between. Neon fills that gap. The official framing is straightforward — pick it when Hydrogen isn't enough but you don't need Carbon's extra layer of verification.

The efficiency gap is what surprises. Artificial Analysis measured Neon's output speed at roughly 110 tokens per second versus 57 for Carbon, which works out to about 40% less time per task. Running the full Intelligence Index costs $6.44 on Neon versus $7.76 on Carbon.

Buried in the same data is a counterintuitive detail: Neon consumes about 15% more output tokens per task than Carbon. Every dollar saved comes from the unit price, not from thriftier token use. That matters if your workload is extreme on the output side — the price gap gets partly eaten by the extra tokens.

On coding, the most crowded battlefield, third-party testing puts Neon at 59 on the Artificial Analysis Coding Agent Index using the Antigravity CLI, against 55 for Carbon. Claude Code with Fable 5.2 and with Opus 5.5 both score 58; Codex with GPT-6.2 Astra scores 53. Google's own figures: 58.6 on its Coding Agent Index, 65.2% on Terminal-Bench 4.1, and 46.2% on FrontierCode 2.0 at the default high setting.

The billing trap: for 12 days, the mid-tier costs more than the flagship

This is where headlines mislead.

Gemini 4 Carbon is still on promotional pricing: $2 input, $10 output per million tokens, good through November 30. On December 1 it reverts to list at $4 / $20.

Neon has no promotion. It launched straight at its permanent $3 / $15.

So there's an awkward window: from November 18 through November 30, Neon costs 50% more per token than Carbon. Only after Carbon's price goes up on December 1 does Neon settle in as the tier that's 25% cheaper than the flagship. Google priced Neon for the post-promotion ladder — it just happened to end its own discount earlier than Carbon's.

The honest framing right now isn't "Neon is cheaper." It's "Neon is faster and scores higher, and you pay a unit-price premium for the next 12 days." Google's own claim is that at the high setting Neon matches Carbon's score at 32% lower cost per task — a comparison that uses Carbon's standard price.

Full price ladder (per million tokens, standard tier):

  • Gemini 4 Hydrogen: $1.50 / $7.50
  • Gemini 4 Carbon: $2 / $10 (promo, through Nov 30) → $4 / $20 (from Dec 1)
  • Gemini 4 Neon: $3 / $15, cached input $0.15
  • Neon on Batch or Flex: $1.50 / $7.50 — exactly Hydrogen's standard rate
  • Neon on Priority: $5.40 / $27

What it's actually good at

Google published a long list of scores. The ones with real signal for ordinary readers:

Enterprise documents and knowledge work

  • Fits spreadsheets, PDFs, charts, audio and video into a single 1M-token window and produces structured deliverables
  • Second on the Vals Index (70.9%); first on both Legal Research Bench and Tax Agent Bench
  • 73.5% on Chartography, which tests reading densely packed professional charts
  • First on Zapier's AutomationBench (56.3%) and first on Andon Labs' Vending-Bench 2 ($16,843), a long-horizon simulation of running a business
  • Debuts second globally on the Agent Arena Index (1336), across 4,200+ real-world agent sessions

Coding

  • Terminal-Bench 4.1: 65.2%
  • 12.8% on the mini-SWE harness, rising to 39.0% inside Antigravity — same model, three times the score, purely from scaffolding
  • In long sessions it cuts redundant file reads and handles context compaction

Science and math

  • Terminal-Bench Science 70.5%
  • RiemannBench 84.0%
  • HLE-Diamond 71.3%

Safety numbers came out too: refusal rates of 1.98% on Terminal-Bench 4.0 and 0% on Terminal-Bench-Science; shortcuts on 2.45% of tasks in Google's coding-cheating evaluation, the lowest of any Gemini 4 model; a 99.2% pass rate on its agent honesty evaluation; and a 0% attack success rate on Gray Swan's indirect prompt injection benchmark at the highest thinking level with real-time safeguards on.

How to use it: three doors

  1. Developers: the paid Gemini API tier (including the Interactions API) and Google AI Studio. Note there is no free tier and no free-quota access.
  2. Subscribers: Google AI Pro and Ultra can pick Neon from the model dropdown in the Gemini app and use it in Antigravity. It replaces Argon and Gemini 3.1 Pro Preview, and 3.5 Flash-Lite now appears as "Auto" in the picker for paid users.
  3. Enterprises: generally available on Vertex AI for verified customers in global, US and EU regions; also reachable through Gemini for business via API or the model dropdown, and through OpenRouter.

Constraints worth knowing before you write code:

  • Text output only. Input can be text, images, video, audio or PDFs (Office and OpenDocument files work too), but it generates no images, no audio, and there is no Live API.
  • Synchronous output defaults to a 65,536 token cap. Anything longer needs background mode or client-side continuation.
  • Caching is implicit only, and only kicks in on prompts of at least 4,096 tokens. Explicit caching is not supported.
  • Sampling parameters such as temperature are ignored; out-of-range values return a 400.
  • Knowledge cutoff is March 2026.
  • Hard prompts can take several minutes, so Google recommends background execution or client timeouts of at least 15 minutes.

Who it's for

  • High-frequency code maintenance: multi-file refactors, cross-repo debugging, test writing — work that demands precision rather than maximum depth
  • Long-document processing: compressing a stack of reports, contracts and PDFs into one conclusion
  • As the orchestrator in an agent pipeline: Google's own demo has Neon directing parallel Hydrogen subagents
  • Batch workloads: on Batch or Flex the price drops to Hydrogen's standard rate, which is where the value case is strongest

Not a good fit: who should skip it

  • One-off problems that need maximum reasoning: that's still Carbon's territory, by Google's own positioning
  • Anything requiring image generation, audio generation or real-time voice: Neon does none of it
  • Teams on a very tight budget who can tolerate slower responses: before November 30, Carbon's promo rate is cheaper per token
  • Anyone hoping to try it free: no free tier, and no Neon trial credit

Three specific pitfalls

  1. The thinking level defaults to high, not low. Code migrated from Hydrogen without an explicit setting will silently run the heavier configuration, raising both latency and bill before any quality difference shows up.
  2. Don't switch blindly during the promo window. Before November 30, Neon costs 50% more than Carbon for the same token volume. If you must switch inside the window, model your input/output ratio first — Neon also spends about 15% more output tokens per task.
  3. Don't expect it to write long documents in one pass. The 65,536 synchronous output cap is a hard wall for long reports and long source files; design the continuation or background flow up front.

Cost and timing: running your own numbers

Rough math at list price, for a task with 200K input tokens and 30K output tokens:

  • Neon: 200K × $3/M + 30K × $15/M = $0.60 + $0.45 = $1.05
  • Carbon at promo: 200K × $2 + 30K × $10 = $0.40 + $0.30 = $0.70
  • Carbon at list: 200K × $4 + 30K × $20 = $0.80 + $0.60 = $1.40

Same job: Neon costs 50% more today and 25% less after December 1. If your inputs dwarf your outputs — reading long documents, editing large repos — Neon's relative advantage grows, because output is where the money goes. For pure generation tasks the gap is smallest.

On speed, both Google and third parties point the same way: about 40% less time per task, at 110 versus 57 output tokens per second. For interactive products, users will notice that long before they notice the price.

Next steps

First: don't change your default model yet. Run Neon and Carbon side by side on three of your own real tasks and record token consumption. Artificial Analysis's "15% more output tokens" is an average; your workload may look nothing like it.

Second: if the answer is yes, roll out gradually before November 30 rather than switching everything — you're paying a unit-price premium during this window. Schedule the full cutover for after December 1, when Carbon moves to $4/$20 and Neon genuinely becomes the middle tier.

Third: if you have large batches and no latency pressure, go straight to Neon on Batch or Flex ($1.50 / $7.50). That's the only combination on the whole ladder offering mid-tier intelligence at entry-level pricing.

> This article is compiled from multiple media reports, together with Google's official announcement. Reporting and independent figures come from 9to5Google, OfficeChai, LLM-Stats and VentureBeat. Artificial Analysis scores and costs are third-party measurements; Google's own scores are self-reported, and the two are labeled separately throughout.

Sources

Comments

0 published
Log inorsign up to leave a comment.

Loading comments...