Gemini 4 Neon for Product Managers: 1M Context, Coding-First, and What It Means for Your Stack
TL;DR
Google released Gemini 4 Neon on November 18, 2026. It is the mid-tier frontier model in the Gemini 4 family, priced at $3 per million input tokens and $15 per million output tokens, with a 1-million-token context window and four thinking levels (low, medium, high, xhigh). At xhigh reasoning, it ranks first on the Artificial Analysis Coding Agent Index with a score of 58.6 and third overall on the Artificial Analysis Intelligence Index. For product managers: Neon is the right choice when you need frontier-class coding and analysis capability at lower cost than Carbon or Argon, and when your workload benefits from long-context reasoning over large codebases or document sets.
The AI PM Minute
One tactic to make you a sharper AI PM, twice a week. 60 seconds to read. Free.
No fluff. Unsubscribe anytime.
What Neon Is and Where It Sits in the Gemini 4 Family
The Gemini 4 family now has four named models with distinct roles. Understanding where Neon fits requires knowing what Carbon, Hydrogen, and Argon each do.
Gemini 4 Argon
Frontier reasoning flagshipGemini 4 Carbon
Planning orchestrator in AntigravityGemini 4 Neon (new)
Coding-focused frontier mid-tierGemini 4 Hydrogen
Fast execution tierNeon fills the gap between Carbon (designed for orchestration) and Hydrogen (designed for speed). It is the model you reach for when you need coding-class intelligence without paying Carbon prices, and when your workloads require sustained reasoning over large inputs.
Benchmark Performance: What the Numbers Mean
Benchmarks are vendor-reported and independently variable, but they tell you something directionally useful. Here is what the publicly available data says about Neon, and what it means for product decisions.
Artificial Analysis Coding Agent Index
58.6 (1st of all tested models)
This measures autonomous coding agent tasks: multi-step code generation, debugging, refactoring across a full project. If your product involves a coding agent, Neon is currently the strongest available model for that workload at this price tier.
Artificial Analysis Intelligence Index
61 at xhigh (3rd overall)
A combined reasoning and language benchmark. Third place behind only the top frontier models. Suggests that for general reasoning tasks, Neon performs at or near the frontier, not just on coding.
Thinking levels (new feature)
Low, medium, high (default), xhigh
You can configure reasoning depth per request. Low is fastest and cheapest; xhigh produces the most accurate outputs but at higher latency and cost. The default is high, which gives you a reasonable quality-speed tradeoff for most use cases.
Cost vs Carbon
Approximately 32% less per task (Google claim)
Google reports Neon is about 32% cheaper per task than Carbon. That figure is model-reported and task-dependent, but directionally consistent with the pricing gap. Validate with your own workload before switching.
A word on benchmark caution: coding agent benchmarks measure performance on standardized tasks in controlled environments. Your codebase, your tooling, and your use case will differ. Run your own evals on a sample of your actual tasks before making a stack decision based solely on published scores.
The 1M Token Context Window: What You Can Actually Do With It
All Gemini 4 models share the 1-million-token context window, but Neon's coding focus makes certain long-context use cases particularly valuable.
Full codebase analysis
50,000 to 500,000 tokens for most production repos
An agent can hold your entire codebase in context and reason about cross-file dependencies, architectural patterns, and regression risks without chunking. For refactoring tasks, this eliminates a major source of agent error.
Long document set reasoning
A 1M-token window holds approximately 750,000 words
Analyzing a full set of technical specifications, legal documents, or financial filings without summarization loss. For enterprise analysis workloads, this removes the retrieval step and its associated accuracy degradation.
Long-horizon agent sessions
A 200-turn conversation at 500 tokens per turn uses 100,000 tokens
Neon can maintain coherence across much longer agentic sessions than shorter-context models. For agents that need to work on a task over hours with many tool calls, the extended context means fewer resets and less context loss.
Multi-file code generation
Generating an entire feature across 20 to 30 files
The model sees all files simultaneously, reducing the cross-file inconsistencies that plague agents with shorter context windows. Types, interfaces, and naming conventions stay coherent across the generated output.
The latency and cost tradeoff at 1M tokens
Filling the full context window is expensive. At $3 per million input tokens, a 1M-token input costs $3 per request. For repeated queries over the same large codebase, prompt caching is essential. Gemini 4 Neon supports cached inputs at $0.15 per million tokens — 20x cheaper — which makes long-context use cases economically viable when the same context is reused across multiple requests.
Develop Your Model Evaluation Skills
The AI PM Masterclass covers how to evaluate model releases, build model selection frameworks, and make architecture decisions that hold up as the model landscape shifts.
Pricing and Cost Modeling
The pricing structure for Gemini 4 Neon has three components. Understanding them is essential before committing a production workload to the model.
Standard input: $3.00 per million tokens
Applies to all tokens sent to the model that are not cached. At typical API request sizes (2,000 to 5,000 tokens), this is $0.006 to $0.015 per request — comparable to frontier model pricing from other providers.
Cached input: $0.15 per million tokens
Applies to input tokens that match a cached prompt prefix. This is the key lever for long-context cost management. If your system prompt or a large document is reused across requests, you pay 20x less for those tokens after the first request.
Output: $15.00 per million tokens
Output tokens are always five times more expensive than standard inputs. Workloads that generate long outputs (code generation, detailed analysis) will see output costs dominate the bill. Use streaming and early stopping where appropriate.
Chat completion (short context)
2K in + 500 out = $0.014 per request
Low volume use cases. Competitive with other frontier models at this scale.
Code generation (medium context)
10K in + 2K out = $0.06 per request
Representative of a single coding task. Scale this by your daily task volume for a monthly estimate.
Codebase analysis (long context, cached)
500K cached in + 1K out = $0.09 for the cache fill, $0.015 subsequent requests
Long-context use cases become economical once the cache is warm. The economics improve sharply at high request volume.
When to Choose Neon vs Other Models
The right model selection decision depends on your workload characteristics, not on which model scored highest on a headline benchmark. Use this framework as a starting point.
Choose Neon when
- •Your primary workload is coding agent tasks (code generation, debugging, multi-file refactoring).
- •You need 1M-token context but want lower cost than Carbon.
- •You are building an agentic coding product and need the strongest available coding performance.
- •Your workload benefits from configurable reasoning depth and you want to tune per-request.
Choose Carbon instead when
- •You are building a multi-agent orchestration layer where the planner model quality is the bottleneck.
- •You need Antigravity's planner-executor split and want the officially supported pairing.
- •Your task requires deep multi-step reasoning rather than coding specifically.
Choose Hydrogen instead when
- •You need fast throughput at high volume and coding quality is secondary.
- •Cost per request matters more than peak performance.
- •You are the executor tier in a multi-agent system where the planner handles complex reasoning.
Consider a non-Google model when
- •Your team has existing fine-tuning on a different provider's base model.
- •You have contractual or compliance requirements tied to a specific provider.
- •You have already benchmarked your specific workload and another model outperforms Neon on your eval suite.
What to Know Before Building on Neon
Access and availability
Neon is available through the paid tier of the Google AI API and in Google AI Studio. Free tier access is not available as of launch. Developers can also use it in Android Studio. GitHub Copilot availability is reported but unconfirmed as of November 21.
Background decoding for long outputs
Synchronous max output is 64K tokens. For outputs up to 1M tokens, the model uses background decoding, which delivers results asynchronously. If your use case requires very long synchronous outputs, test this flow carefully in your integration.
Neon can orchestrate Hydrogen subagents
In Antigravity environments, Neon can act as a planner that spawns Gemini 4 Hydrogen subagents working in parallel. This is a different architecture from Carbon-Hydrogen, where Carbon is the designated planner. Evaluate which planner model fits your orchestration needs.
Latency at xhigh reasoning
The xhigh thinking level delivers the strongest benchmark performance but at increased latency. For user-facing features, test time-to-first-token at each thinking level before choosing one for production. The default high level is likely the right starting point for most real-time use cases.
Independent benchmarking is limited
Neon launched November 18 and third-party benchmarking is sparse. Google's own figures are the primary available data. Run your own evals before making a production commitment, especially if you are comparing against an incumbent model.
Evaluate Models Like an AI PM, Not Like a Developer
The AI PM Masterclass teaches you how to build model evaluation frameworks, interpret benchmark data, and make architecture decisions that hold up as the landscape shifts.
Related Articles
Before you go: get the AI PM Minute
One tactic to make you a sharper AI PM, twice a week. 60 seconds to read. Free.
No fluff. Unsubscribe anytime.