By Mahan Kenway | November 19, 2026
Disclosure: This article was researched, written, and fact-checked by an autonomous AI assistant for Mahan Kenway. Cover image: original AI-generated editorial illustration; it is conceptual, not a photograph of Google's hardware.
Google's latest Gemini release makes a useful distinction that gets lost in model-launch headlines: the cheapest token is not necessarily the cheapest completed task. Gemini 4 Neon is designed for difficult coding and analysis jobs where a model may read files, call tools, reason, and revise before it produces an answer. The real question is whether it can finish those jobs reliably enough, and with few enough steps, to justify its price.
Google announced Gemini 4 Neon on November 18. The stable model ID is gemini-4-neon. It accepts text, images, audio, video, and PDFs, and outputs text. It offers a unified 1,048,576-token context window and four thinking levels, with high as the default. Google is rolling it out in the Gemini API and other products; access and plan requirements differ by product. The developer documentation lists it on the paid Gemini API tier.
Here's what matters if you're deciding whether to use it, rather than just comparing launch-day leaderboards.
The important price is the price of a successful task
On the standard paid Gemini Developer API tier, Google lists Neon at $3 per million input tokens and $15 per million output tokens, including thinking tokens. Qualifying implicit cache reads cost $0.15 per million input tokens; explicit caching is not supported for this model. Neon is not available on the free API tier. Check Google's current pricing page for details and changing terms.
For a simple illustration, a request with 50,000 uncached input tokens and 6,000 billed output tokens, including any thinking, would cost approximately $0.24 at those rates. That's $0.15 for input plus $0.09 for output. This is not a quote for an actual workload: caching, tool charges, repeated calls, retries, and product-specific pricing can change the total. A Search-grounded request, for example, may incur separate query charges after the applicable allowance.
That distinction matters for agents. A model that makes ten tool calls, rereads a repository, and tries three patches may cost more per solved issue than a higher-priced model that succeeds in one clean attempt. The reverse can also be true if the expensive model doesn't improve success enough. Track cost per accepted task, not just cost per call: count failures, retries, verification, and the engineer's review time as well as tokens.
Google claims Neon at its default high setting achieves a 32% lower cost per task than Gemini 4 Carbon on an Artificial Analysis benchmark. Treat that as a benchmark-specific claim, not a guaranteed saving on your application. In fact, Google's Cloud pricing lists promotional global rates for Carbon of $2 input and $10 output per million tokens through November 30, rising to $4 and $20 from December 1. Neon is therefore more expensive per token than Carbon's promotional rate at the time of writing, even if it can use fewer tokens on some tasks. Hydrogen's listed global rate is $1.50 input and $7.50 output. Compare the current prices and the specific service you actually use before committing.
As AI Weekly observed, Google is “matching frontier pricing” rather than simply winning on cheap tokens. Whether that price makes sense depends on your task mix.
Four thinking levels, one shared budget
Neon supports low, medium, high, and xhigh. Google says the lower settings use fewer tokens and generally respond faster, while xhigh is intended for especially difficult multi-step problems. Start by evaluating the default high against your own test set, then see whether a cheaper or faster level meets the same quality bar. Use xhigh when the additional reasoning actually improves outcomes, not merely because it is available.
There is a subtle implementation detail: input, thinking, and output all share the same context window. The model's specification lists a default synchronous maximum output of 65,536 tokens, with longer generation possible through supported long-decode mechanisms. The launch guide also explains that max_output_tokens caps thinking and final output together. If the limit is too low, a long reasoning process can leave too little room for the answer.
A large context window is useful, but it is not a promise that every detail will be remembered equally well. For a codebase, retrieve the relevant files, ask the agent to cite paths and line numbers where possible, and run checks against the actual repository. Treat the 1M limit as a capacity ceiling, not an instruction to send everything on every request.
What the benchmarks do, and don't, establish
Google's launch post reports a 58.6 score for Neon on the Artificial Analysis Coding Agent Index and 65.2% on Terminal-Bench 4.1. It also says Neon scored 12.8% on SWE-sweep using the mini-SWE harness and 39.0% using Google Antigravity. These are provider-reported launch results. The difference between harnesses is itself a useful warning: an agent's tools, instructions, environment, and retries can matter as much as the model name.
Artificial Analysis describes its coding-agent index as an equally weighted composite of implementation, terminal, and repository question-answering benchmarks, with three attempts per task. That makes it a richer signal than a single coding puzzle, but not a substitute for testing against your own languages, dependencies, security rules, and review standards. Rankings can change as the benchmark and competing models change.
The independent evaluator's Neon model page also shows why “fast” needs a workload qualifier. In its Intelligence Index measurements, xhigh averaged 21.5 minutes per task versus 14.8 minutes for high; its page describes xhigh as slow relative to comparable models. These are benchmark averages, not a prediction of latency for your app. Compare complete task time and user experience, not only tokens per second.
A minimal API starting point
Google's Neon quickstart uses the Google Gen AI SDK and the Interactions API. With the SDK installed and credentials configured, a small request looks like this:
from google import genai client = genai.Client() result = client.interactions.create( model="gemini-4-neon", input="Explain the tradeoffs of adding a retry queue to an HTTP service.", generation_config={"thinking_level": "high"}, ) print(result.output_text) This is a starting point, not a production-ready agent. Add sensible timeouts, error handling, spend limits, and evaluation before wiring a model to real systems. For code-writing workflows, run generated changes in an isolated environment and keep secrets and production credentials out of the agent's reach. Require human approval before deployment or other irreversible actions.
The limits that deserve attention
Neon is a proprietary model with hosted access; Google's model card lists a March 2026 knowledge cutoff and warns that hallucinations remain possible. That matters for current API changes and recent security issues: verify important claims against live documentation and tools. Multimodal input also does not mean the model generates every media type. The specification lists text output, and says image generation, audio generation, and the Live API are not supported for this model.
Google says Neon showed a capability increase over Argon below its own threshold for a full new critical-capability assessment. Its model card carries forward several Argon risk determinations and says a fuller Neon safety and security report will follow. That is information about Google's assessment process, not proof the model is safe for every deployment. Prompt injection, over-permissioned tools, and mistakes in generated code remain application-level risks even when a model scores well on evaluations.
A practical way to decide
Build a small set of real tasks before moving traffic. Include easy jobs, ambiguous bugs, multi-file changes, and cases where the correct response is to ask for more information. Compare Neon at medium, high, and, for the hardest cases, xhigh against the model you already use. Keep the same tests and tool permissions for each run. Record correctness after review, total token spend including thinking and retries, end-to-end latency, and how often an answer needs substantial repair.
If Neon solves difficult jobs with fewer retries, its higher unit price may pay for itself. If a lighter model clears your quality bar, keep the cheaper route and reserve Neon for escalation. The best result from this launch is not a new default for every prompt; it's another option for choosing the right amount of reasoning for the work.


