AI AgentAI CodingInference & Performance

Cheaper Than the Flagship Yet Higher-Scoring: What the Newly Launched Gemini 4 Neon Reveals About Google's Single-Session Dual-Model Relay

When writing code with large language models day to day or running a coding agent across dozens of turns, one major challenge is keeping costs as low as possible without sacrificing quality. Two major labs had already put forward distinct approaches. In the official cost-saving guide we previously reviewed, Anthropic (the maker of Claude) recommends sticking with a single high-quality model throughout the same session while dialing down its thinking effort level, cutting costs by reducing the internal reasoning steps the model performs before generating an answer. DeepSeek, in the persistent coding agent we analyzed earlier, splits the work across two tiers—a project manager and sub-agents—but because both tiers have to re-read the context, the setup incurs 3.8x redundant read overhead.

Over the past five weeks, however, Google has shipped four next-generation models in rapid succession. On November 18, 2026, it released the fourth, Gemini 4 Neon, while introducing a dual-model orchestration mode called Orchestrator (Neon) inside its own coding tool, Antigravity. This mid-priced new model beat the flagship Carbon—soon returning to its full price—in benchmarks, while bringing single-session dual-model relay to mainstream paid subscribers. Comparing all three companies reveals a third path for reducing coding-agent costs.

Priced a Quarter Lower Yet Outscoring the Flagship: What Is the Newly Launched Neon?

Start with pricing. Both Google’s earliest release, Argon, and the flagship Carbon are currently running at half-price promotional rates. On December 1, both will double back to the exact same list price: $4 per million input tokens and $20 per million output tokens (with the model’s internal thinking process billed at the pricier output rate). At identical list prices, the stronger Carbon immediately left Argon hard to justify. Worse still, the budget-friendly Hydrogen—launched just days earlier—includes a free tier and costs less than 40% of the flagship at paid rates, yet still beat Argon on benchmarks. Squeezed from both ends, Argon was simply dropped from the main recommendation table in the newly updated official Gemini model selection guide.

Stepping into the workhorse slot, Neon skips any promotional window and launches directly at a fixed list price of $3 per million input tokens and $15 per million output tokens—a quarter below the flagship’s list price. Many initially assumed it was just a sub-flagship meant to plug a pricing gap, until the newly published official Neon model card revealed that it is adapted directly from the flagship Carbon. Its post-training focused heavily on coding-agent performance, while pushing the rate of shortcut-taking during coding down to the lowest in the entire lineup.

Once list pricing returns, Carbon-derived Gemini 4 Neon outperforms the flagship Carbon on both the overall intelligence index and per-task cost at a lower unit price, replacing Argon as the new workhorse.

In the independent evaluations shared in the official Neon launch blog, it overtook the flagship outright on the overall leaderboard. On the Artificial Analysis Intelligence Index, Neon scored 61 at its highest thinking level (xhigh), edging past the flagship Carbon’s 60. Even at the default high setting, it ties Carbon while cutting total per-task cost by 32%, and takes the #1 spot globally on the coding-agent leaderboard. Neon thus naturally takes over from the barely month-old Argon as the recommended workhorse and sits pinned at the top as the default model for new sessions in Antigravity. The pricier Carbon retreats to the high-end Ultra subscription to tackle ultra-long-horizon research problems, while high-frequency, lightweight everyday development goes to Hydrogen and its free tier.

Anthropic Urges Sticking to One Model and DeepSeek’s Two-Tier Split Burns Extra Cache—How Does Google Make Single-Session Dual-Model Relay Work?

Once you have models at different capability tiers, the intuitive idea is to let a strong model set direction while a cheaper model writes the code. In engineering practice, however, that runs into two obstacles: cache invalidation and broken handoffs. At every step, a coding agent resends the prior conversation history and tool definitions. Servers store that already-computed repeated prefix and bill it at a discount—known as prefix caching. But prefix caches are bound to a specific model; different models cannot share them.

In its official guide on optimizing for cost and intelligence, Anthropic aggregated data across many teams and found that nearly 90% of inputs in coding loops rely on prefix caching for savings. On Anthropic’s platform, though, writing history into the cache for the first time carries a 25% write premium. Switching models mid-session invalidates the accumulated cache and forces the new model to pay that write premium all over again, wiping out the savings from a lower per-token rate. What about coding with a cheaper model end-to-end and only consulting a stronger model when stuck? Across nearly 400 experiments, Anthropic never saw the cheaper model proactively ask for help even once, because smaller models simply do not know when they are stuck. That is why Anthropic recommends sticking with one strong model and lowering its thinking effort to control costs.

On the flip side, having a strong model direct work inside a single window and delegate only large tasks to sub-agents also breaks down. While testing its persistent coding agent, DeepSeek found that whenever the prompt left room for small tasks to be handled directly, the main model could not resist jumping in to write code itself in 1 out of every 5 turns—locking up the conversation window for nearly half an hour. To fix this, DeepSeek split the system into two separate sessions and stripped the project manager of coding tools altogether, limiting it to filing work tickets for background sub-agents. That cured the urge to meddle, but because both sides had to re-read the codebase and conversation history independently, it burned nearly four times as many cached tokens.

With a single model too expensive and a two-tier split too cache-hungry, Google chose a third path: passing the baton directly within the same session. Previously, teams hesitated to switch models mid-session not only because of cache invalidation, but also because the train of thought would break—a cheaper model seeing only a few lines of conclusions could easily veer off course. According to the Gemini thinking documentation, before answering each turn, Gemini 4 packages its internal deliberation into a thought signature stored on the backend. When handing off to a cheaper model, the backend automatically carries that signature over, allowing the incoming model to pick up right where the previous one left off.

So why does Anthropic warn against switching models mid-session while Google makes the math work? Both platforms share the same constraint that caches cannot be shared across models—on the handoff turn, the new model still has to re-read the context at full price. The difference comes down to the cost of the handoff and the payoff that follows. Anthropic charges a 25% cache-write fee, so switching midway through an already-long session means the re-read plus write fee immediately eats up any per-token savings. Google uses implicit caching, which automatically applies a 95% discount once input crosses a threshold and charges no write fee, making the toll for switching models much lower. Even more importantly, there is timing: Orchestrator (Neon) hands off to Hydrogen early, right after initial planning when the context is still short. Over the dozen-plus turns of writing code and running tests that follow, the bulk of the bill actually comes from model outputs—output pricing is 5x input pricing, and Hydrogen’s output rate is half of Neon’s—while repeated inputs on each turn hit Hydrogen’s own cache. Paying a small one-time toll while the context is short in exchange for cutting output costs in half over the next dozen-plus turns easily pays for itself.

Built on these underlying primitives, Google introduced Orchestrator (Neon) in the Antigravity models and orchestration documentation, allowing two models to pass the baton within the same turn. Whenever a request arrives, Neon first enters read-only mode to explore the codebase, draft a plan, and specify the conditions that should trigger replanning. Once the plan is set, the system hands off within the same session to the cheaper Hydrogen to edit code and run tests. During execution, if tests fail twice in a row, an interface behaves unexpectedly, or the agent hits an undecided design branch, control automatically bounces back to Neon to inspect the state and revise the plan, then returns to Hydrogen to keep going. Last week, Google first rolled out an orchestration mode pairing the flagship Carbon with Hydrogen. According to coding benchmark results published on the official Antigravity blog, this dual-model relay came close to matching the flagship solo in success rate while saving 24% of quota on average and running nearly 20% faster. Swapping in the cheaper Neon to create Orchestrator (Neon) brings the workflow down from the pricey Ultra tier to the mainstream paid Pro subscription.

Anthropic preserves cache by lowering effort on a single model, DeepSeek cures meddling with two-tier isolation at the cost of 3.8x cache overhead, and Google’s Orchestrator achieves single-session dual-model relay through read-only planning and two-failure bounce-back.

Why Switching to Smaller Models Demands Extra Rules: The Inevitable Pull from Result Certainty Back to Process Certainty

Setting aside details like cache discounts and API parameters for a moment, the divergence across these three labs reflects two distinct control philosophies in agent engineering. I compared both in an earlier post, From Process Certainty to Result Certainty. Result certainty does not dictate every individual step; it defines the final acceptance criteria and relies on the model’s reasoning, observation, and self-correction to reach the goal. Process certainty, by contrast, enforces hard constraints on workflow stages, tool permissions, and external trigger conditions. The former leans on model discretion; the latter leans on procedural guardrails to guarantee reliability.

Which approach works better depends on whether your model is smart enough. For a flagship model like Anthropic’s, with strong instruction-following and sound judgment, relying on single-model result certainty makes sense: state the goal clearly, and it knows on its own when to inspect code and when to pivot, without extra ceremony. Under cost pressure, however, when you swap in a smaller model—or try to separate roles purely via prompts inside a single window—cracks appear. Smaller models often fail to follow implicit instructions reliably and may not even recognize when they are stuck; across nearly 400 trials, Anthropic never saw one ask for help on its own. Meanwhile, DeepSeek observed that even a strong model, when given coding tools in the same window, cannot always resist the impulse to start coding itself. At that point, external process certainty has to step in as a backstop.

Both DeepSeek and Google build process certainty into their designs, just at different intensities. DeepSeek applies a heavy version—physically splitting the workflow into two sessions and removing coding tools from the project manager—so the main model cannot attempt to write code at all, at the cost of both sessions re-reading the repository and burning 3.8x extra cache. Google’s Orchestrator (Neon) introduces process certainty as well, but keeps it lightweight and inside a single session: restricting the strong model to read-only permissions during planning so it cannot meddle, and using explicit external signals like two consecutive test failures during execution to bounce a derailed smaller model back to the stronger one. Using the lightest possible process certainty to put a floor under the smaller model while preserving single-session context and cache continuity is what makes dual-model relay work effectively.

How to Pick Tiers and Borrow This Pattern for Your Active Agent Workflows

If you code directly in Antigravity, Orchestrator (Neon) is the straightforward pick for everyday development, bug fixes, and cross-file refactors; the only caveat is that its internal routing ratio is fixed, so you cannot manually adjust thinking effort. For quick script edits, dependency bumps, or adding unit tests, picking Hydrogen directly—with its free tier—is faster. Save direct Neon at high or xhigh for complex system design where every step demands deep deliberation.

If you build your own agents via the API, consider migrating legacy Argon setups to a Neon-plus-Hydrogen pairing before list pricing returns at the end of the month. Along with that switch, you can borrow the official orchestrator’s two lightweight rules directly: first, lock tools to read-only during planning so the strong model is forced to produce a plan and exception triggers rather than casually emitting walls of boilerplate; second, never count on a smaller model to ask for help on its own—use explicit signals such as two consecutive test failures to force a switch back to the strong model for replanning.

Before putting this into production, keep two caveats in mind. First, Neon just launched and has not yet been battle-tested beyond official and partner leaderboards; real-world consensus on ultra-long conversations and obscure codebases will take a few weeks of community use to settle. Second, if certain exceptionally hard tasks still require calling Carbon, watch out for production latency swings. According to production monitoring from the routing platform OrcaRouter, over the past week half of Carbon’s requests waited more than 10 seconds for the first token, and nearly a quarter failed outright. Google also recommends setting timeouts of at least 15 minutes for complex requests or running them in the background. Wire up generous timeouts and error retries in your code first, and you will be on much firmer ground when cutting over to this dual-model pipeline.