TECHNICAL DEEP DIVE

Gemini 4 Neon for Product Managers: 1M Context, Coding-First, and What It Means for Your Stack

By Institute of AI PM·14 min read·Nov 21, 2026

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 flagship
Context: 1M tokens
Price: Highest tier
Best for: Complex multi-step reasoning tasks where cost is secondary. Research, long-horizon planning, tasks requiring the highest accuracy.

Gemini 4 Carbon

Planning orchestrator in Antigravity
Context: 1M tokens
Price: High tier
Best for: Planner role in multi-agent systems. Breaks complex goals into subagent tasks. Pairs with Hydrogen as the executor.

Gemini 4 Neon (new)

Coding-focused frontier mid-tier
Context: 1M tokens
Price: $3/$15 per million tokens
Best for: High-quality coding tasks, complex analysis over large codebases or documents. #1 on coding agent benchmarks.

Gemini 4 Hydrogen

Fast execution tier
Context: 1M tokens
Price: $1.50/M input tokens
Best for: High-volume execution tasks where speed matters more than peak reasoning quality. Executor role in Antigravity.

Neon 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.

1

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.

2

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.

3

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.

4

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.

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.