
Gemini 4 Neon vs Gemini 4 Carbon for Coding, Cost, and Routing
Compare Neon and Carbon on coding, migration, and automation. See how the December price change and retries affect task cost, then test a routing policy.
On this page
high for frequent, well-scoped engineering tasks. Keep Carbon as the baseline for difficult architecture work and workflows it already handles reliably. On CursorBench 4.1, Neon high scored 63.7% versus Carbon high at 61.5% and cost less per task in that benchmark. Use your account's Carbon rate and both models' success on your own failure cases to decide how to route traffic. CursorBench 4.1Which tasks suit Gemini 4 Neon and Carbon?
| Job | Starting choice | What would change the decision |
|---|---|---|
| Recurring cross-file bug with a reproducible failure | Neon high | Carbon consistently resolves cases Neon leaves incomplete |
| Ambiguous architecture change with costly rework | Your validated model, with Carbon as a baseline | Neon meets the same integration checks and review bar at lower total cost |
| Monthly analysis with fixed outputs and traceable sources | Evaluate Neon alongside your current route | A cheaper configuration delivers equally reliable source references |
| A failed job with missing inputs or a broken tool | Resolve the missing input or tool failure | Rerun once the prerequisite is restored |
An invoice rounding bug gives the agent a clear target. The failing test shows where the totals diverge, and the patch has to preserve historical invoices and refund behavior. Reworking how pricing and billing services share state calls for decisions about boundaries, recovery, and compatibility. Unit tests can cover only part of that work, so keep Carbon as a baseline for a change like that.
What changes at higher thinking levels?
CursorBench 4.1 uses ambiguous, multi-file tasks drawn from real Cursor sessions. Its configurations give teams several starting points.
| CursorBench 4.1 configuration | Score | Listed cost per task |
|---|---|---|
Neon medium | 57.7% | $3.07 |
Carbon medium | 60.4% | $7.22 |
Carbon high | 61.5% | $8.52 |
Neon high | 63.7% | $6.54 |
Neon xhigh | 65.4% | $10.67 |
high to xhigh added 1.7 percentage points and $4.13 per task. Test xhigh when you can identify difficult jobs before they run, then compare it against Carbon with the same checks and time limit. Cursor's costs reflect its own benchmark setup. CursorBench results and methodology
high and Carbon high both rounded to 60. Neon took 14.8 minutes and $3.74 per task on average. Carbon averaged 37.1 minutes, with a cost of $7.76 at regular rates. In Plotly's separate data analysis benchmark, Neon was faster and cost more. Record latency and spend separately. Figures checked on November 19, 2026. Artificial Analysis model data · Plotly data-analysis benchmarkWhy benchmarks disagree
| Evaluation | Neon | Carbon | Decision it informs |
|---|---|---|---|
| Vals Code Migration v1.1, Vals Index subset | 75.8% | 80.1% | Include Carbon when a language migration must preserve behavior |
Zapier AutomationBench, both high | 54.3%, $0.88/task estimated | 53.9%, $1.94/task estimated | Check whether Neon completes routine tool workflows at lower cost |
| Plotly data analysis | 43/43, 46 s median, $17.03/run | 42/43, 93 s median, $11.55/run | Budget speed and cost separately |

How Carbon’s December price change affects your budget
These are Google's standard API prices in USD per million tokens.
| Model and period | Input | Output | Cached input |
|---|---|---|---|
| Neon | $3 | $15 | $0.15 |
| Carbon through November 30, 2026 | $2 | $10 | $0.10 |
| Carbon from December 1, 2026 | $4 | $20 | $0.20 |

Where retries erase the cost advantage
Use failure reasons to decide which tasks go to Carbon. A patch that passes unit tests but changes an established refund total is a candidate for a second pass if the model has enough evidence to correct it. A missing database export, unavailable tool, or denied permission needs the prerequisite restored. A second model call in those cases generally adds spend without addressing the failure.
Migrate one class of tasks at a time
Take recent tasks your existing model has already run. Group them by deliverable. A small patch, a diagnosis across several files, and a design with compatibility constraints need different checks. Replay each task from the same repository snapshot with the same tools and acceptance checks.
Use hard cases your baseline handles to set routing rules
Build a replay set that covers well-scoped code fixes, ambiguous failures across components, and long changes that must preserve public behavior. Include past near-misses, such as a patch that changed a default, an old fixture that hid a regression, or a plausible report based on a stale source. For each task, save the starting revision, visible instructions, allowed tools, and what qualifies as finished.
Record the median and slow-end completion time for each configuration, including tool waits and retries. If a request is time-sensitive, look at the long-running tail before routing live traffic. If work runs overnight, accepted-task cost and the morning review queue may matter more than median latency. Record uncached input, cache hits, billable output, and human review separately so you can price the same trace under a later rate schedule.
Compare direct calls with a single escalation
Keep one Carbon-only baseline. Compare it with Neon alone and with Neon followed by one Carbon attempt after a detected, recoverable failure. Keep the task budget, permissions, and acceptance tests fixed. If the two-model path is valuable, its logs tell you which task class to move and which failure triggers actually pay for themselves. If almost every attempt escalates, start that class on Carbon and note the evidence for the rule.
FAQ
Is Neon always cheaper than Carbon?
Google's per-token rates favor Carbon during its introductory period and Neon at regular rates. Task cost also depends on usage and retries.
Which is the better first test for multi-file coding?
high is a practical candidate for recurring work with clear checks. Include your current Carbon configuration.Do both have a one-million-token context?
Google documents a shared one-million-token window for both. Check output and continuation limits on your chosen interface.
Do they have the same default thinking level?
high for Neon and medium for Carbon.Should I send hard cases to Neon xhigh or Carbon?
Compare the two on the failure modes you actually see and record whether the extra attempt resolves the work.


