DEV Community

Cover image for Token price lies: how Gemini 4 Neon cuts your API bill
Andrey Altrouter
Andrey Altrouter

Posted on Originally published at altrouter.ai

Token price lies: how Gemini 4 Neon cuts your API bill

Running autonomous coding agents requires precise session cost calculations. Nominal rates for new models often hide the actual cost structure. The bulk of your budget goes to invisible reasoning tokens and context operations.

Switching agentic development workflows to Gemini 4 Neon cuts final costs by 32 to 36 percent compared to Gemini 4 Carbon and Claude through free cache writes and fewer revisions, provided you force the default reasoning level down and keep prefixes longer than 4096 tokens.

The price paradox: why Neon is cheaper than Carbon in tests

Until November 30, 2026, the flagship Gemini 4 Carbon runs on a promo rate of $2 per million input tokens and $10 per million output tokens. The base price for the intermediate Gemini 4 Neon model, released on November 18, 2026, is fixed at $3 for input and $15 for output. At first glance, the flagship model appears 33 percent cheaper. On December 1, 2026, Carbon will go up to $4 and $20. Neon's permanent price will then sit 25 percent below the flagship.

Even now with a higher nominal rate, Neon proves more cost-effective in actual workloads. In Google Antigravity environment tests, the cost of solving end-to-end development tasks with Neon is 32 percent lower than with Carbon. The model generates concise code and requires fewer wasted revision cycles. The Models Engineering Index rates a model's ability to solve real tasks from GitHub repositories. The new release scored 68.1 points, beating Claude Fable 5.2 with its 66.3 points, Claude Opus 5.5 with 60.8 points, and Gemini 4 Carbon itself with a score of 60.6.

In the Terminal-Bench 4.1 agent test adjusted for cheating, the model achieved 65.2 percent when run through Antigravity-CLI 1.5.9. The Artificial Analysis Coding Agent Index benchmark evaluated the model on its ability to autonomously navigate a file system and fix bugs. The new model took first place with a score of 58.6 points.

Developers on Hacker News joke about Google's naming convention, comparing the lineup to the periodic table. Users try to map out the release logic. Hydrogen acts as the base and weakest model. Neon follows it. Then comes Gemini 4 Argon. Carbon serves as the flagship. Commenters mock the addition of carbon to a series of noble gases.

Discussions highlight the unusual architecture of the new release. Neon is based on a compact Hydrogen-class base checkpoint. The model outperforms the heavy Carbon through deep RL optimization for agentic environments. Commenters call Neon the long-awaited successor to Gemini 3.1 Pro. Users see better response times with quality comparable to Claude Opus 5.5. The community praises the shrinking gap with OpenAI and Anthropic models in Terminal-Bench and SWE-bench tests. Commenters consider this gap the primary detector of marketing exaggeration. Comparing costs across different architectures works best through log analysis. General principles of cost formation are described in our article about neural network API prices.

The hidden counter: how reasoning tokens drain the budget

In coding agents, hidden reasoning tokens account for up to 70 to 85 percent of the response cost. The model generates a chain of thought before delivering the final answer. These tokens remain invisible to the user. The developer receives only the final code but pays for the entire generation process. Hidden tokens are billed at the full output rate: $15.00 per million tokens. This makes the nominal $3.00 input price deceptive. The main expenses accumulate during the output phase.

Google does not publish the exact hardware boundaries for chain-of-thought generation. The volume of hidden tokens lacks strict limits and depends directly on prompt complexity. By default, the API uses a high reasoning level, which multiplies the final bill.

Reasoning level Average task cost Default status
low $0.75 Disabled
medium $1.90 Disabled
high $3.74 Enabled
xhigh $6.44 Disabled

Executing a task at the default high level costs $3.74 on average compared to $0.75 at the low level. Let us calculate a typical cold call with 10,000 input tokens on the standard paid tier. Imagine a task to refactor a large component. The script sends 10,000 input tokens. At the $3.00 per million rate, this costs $0.030. The model starts working at the default high level. It generates 2,000 hidden reasoning tokens while analyzing dependencies and code structure. Then it outputs 1,000 tokens of useful response. The billing system adds these values together. The result is 3,000 output tokens. We multiply them by the $0.000015 per token rate. The output costs $0.045. We add input and output. The final bill for one request comes to $0.075, or 7.5 cents.

The lack of hard limits on invisible token volume creates budget risks. A complex prompt forces the model to generate thousands of hidden tokens. If an agent operates in an autonomous loop and constantly hits compilation errors, background calls at the high level will quickly drain your daily funds limit. The xhigh mode increases the average task cost to $6.44. Its use is justified only for the most complex algorithmic problems. To avoid overspending, developers implement limits at the application level. We covered this approach in detail in our article on how to reduce token costs.

Free cache writes: the math behind bill reduction

Neon's caching approach differs from Anthropic models. With competitors, the developer pays a separate price to create the cache. The Cache Write rate ranges from $2.50 to $5.00 per million tokens depending on the Claude version. With Neon, implicit caching turns on automatically for prefixes of 4,096 tokens or more. There is absolutely no charge for writing and storing data.

A metal coin on a white thread, half lowered into the slot of a white piggy bank.

Reading this cache provides a 95 percent discount off the base rate. Processing a million cached tokens costs just $0.15.

Consider an interactive IDE session with repeated access to the codebase. The script sends the same 10,000 context tokens. They are already in the cache. The input costs $0.0015 instead of $0.030. The program asks for a quick fix in one function. The script programmatically lowers the reasoning level to medium, since complex architectural thought is unnecessary here. The model generates 500 response tokens and 800 reasoning tokens. These 1,300 tokens are multiplied by the $0.000015 rate. The output will cost $0.0195. The repeated call costs $0.021, or 2.1 cents. If the cache had missed, this exact call would have cost significantly more.

The absence of cache write fees radically changes the economics of long sessions. Independent developers analyzed the logs of the Claude Code plugin. They migrated their workflows from the base model to Neon. The replacement dropped weekly expenses from $72.67 to $46.54. The net savings reached 36 percent. Billing analysis revealed the reason for this drop. Seventy percent of the saved funds were preserved specifically due to free context storage. When working with Claude, the plugin constantly overwrote the cache as files changed, generating additional costs under the Cache Write rate. Neon simply reads the updated prefix at a discount.

A developer can load the entire project documentation and source code into a single system prompt. With every new question, the system will read this data array at a discount. The main condition is keeping the initial part of the prompt unchanged. Any modification in the first few thousand tokens will flush the cache, triggering billing at the full $3.00 per million rate. The implicit mechanism works transparently and requires no additional endpoints.

Silent breakage of old API configurations

During migration, old API configurations will stop working without throwing errors. The Google Cloud documentation explicitly states that Neon completely ignores classic sampling parameters.

A metal adjustment toggle switch ripped from a panel and lying on a table.

A developer can no longer control generation creativity through familiar parameters. The temperature, top_p, and top_k fields exist in the request schemas, but the API skips them. Attempts to make the code strictly deterministic by setting a zero temperature will yield no results. Developers often use zero temperature to extract structured data. They expect to receive valid JSON without excess reasoning. With Neon, this approach fails. The model ignores creativity settings and relies solely on internal sampling algorithms. Repetition penalties like frequency_penalty and presence_penalty are disabled on Google's servers. Explicit cache management has been deprecated. Now only automatic implicit caching is available.

The only working lever for controlling generation remains the thinking_level parameter. Four values are available: low, medium, high, and xhigh. The minimal mode is not supported.

This breaks scripts tightly bound to generation determinism. If application logic demands a zero temperature for predictable JSON parsing, Neon will return an unexpected result. On Hacker News, developers complain about the inability to run the model under student Google accounts. Users assume a commercial account is required. Neon completely lacks a free tier in the API and Google AI Studio. The model is available only to users with active paid billing or Google AI Pro and Ultra subscriptions. The vendor does not clarify plans to open free access after the Gemini 4 family promo period ends. The lack of a free tier complicates hypothesis testing for independent researchers. Forum commenters express dissatisfaction with the disappearance of familiar generation control tools.

Implementation rules: setting parameters and tiers

For standard editing and refactoring tasks, hardcode the reasoning level to medium or low. Keep the default high level only for complex architectural decisions where the model must design logic from scratch.

from google import genai
from google.genai import types

client = genai.Client(api_key="YOUR_API_KEY")

response = client.models.generate_content(
    model="gemini-4-neon",
    contents="Refactor this database class",
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(
            thinking_level="medium"
        )
    )
)

print(response.text)
Enter fullscreen mode Exit fullscreen mode

Group the codebase context into an immutable prefix. To get the 95 percent discount, the size of this prefix must strictly exceed 4,096 tokens. The unified context window holds up to a million tokens for input. This volume is enough to load several large repositories along with their documentation. A response for a single segment in long decode mode is limited to 65,536 tokens. This allows generating entire code files without cutting off in the middle of a function. The model's knowledge is limited to March 2026.

Split tasks by pricing tiers. Move background tests and bulk log analysis to Batch or Flex modes. They provide a 50 percent discount and lower the price to $1.50 for input and $7.50 for output. Standard cached input on these tiers costs $0.075 per million tokens. These modes fit well for overnight test runs.

For critical latency requirements, the vendor mandates using the Priority tier. It includes an 80 percent markup. On this tier, input will cost $5.40, and output will cost $27.00 per million tokens. Cached input costs $0.27. There is no official latency SLA on the Standard tier. Only Priority guarantees minimal response time under peak cluster loads. The specialized secure Neon Cyber version is currently available only to participants of the closed Google Fairwind program, with no exact dates for a public API release. Using aggregators like altrouter.ai allows testing new models alongside the Claude and GPT stack without being tied to Google Cloud billing.

Top comments (0)