Gemini 4 Neon Tops Coding Agent Index with 58.6 — What's Behind the Score

Gemini 4 Neon tops the coding Agent index, but the aggregate score blends task types — combine individual results with real testing.
Google's Gemini 4 Neon ranks first on the Artificial Analysis Coding Agent Index at 58.6, but the index blends codebase understanding, code modification, bug fixing, and CLI tasks, so one score doesn't mean across-the-board leadership — Cloud Opus 5.5 still leads on Terminal Bench 4.1 and Frontier Code 2.0. Neon offers 1M-token context and four thinking levels, priced at $3/$15 per million input/output tokens.
Google has launched Gemini 4 Neon, an AI model built for software engineering, analytical work, and multi-step tasks. It ranks first on the Artificial Analysis Coding Agent Index with a score of 58.6. That result is impressive enough, but it's far more precise than the claim that "Neon beats every rival at coding" — the index blends multiple kinds of software work tasks, and a single aggregate score can't tell the whole story.
One Score, Many Capability Dimensions
The Artificial Analysis Coding Agent Index was designed to measure different types of software work together. Some tasks test whether the Agent can understand a codebase; others require it to modify code, fix bugs, or get work done through a command-line interface.

This means a model can excel at one category of task while struggling with another. The evaluators themselves recommend reading the aggregate score alongside individual results rather than fixating on the ranking alone. Google's published comparison data bears this out: Neon leads in some evaluations, while Cloud Opus 5.5 still holds the advantage in others, including Terminal Bench 4.1 and Frontier Code 2.0.
For development teams, this distinction has real practical significance. Understanding an unfamiliar code repository and successfully fixing it are related tasks, but they place different demands on an AI Agent. The former tests context absorption and comprehension of code structure; the latter tests precise localization and modification capability. A model that is strong in the former but weak in the latter — or vice versa — directly affects its value in real workflows.
Artificial Analysis Coding Agent Index is a benchmark maintained by the independent evaluation firm Artificial Analysis, specifically assessing how AI Agents perform on real software engineering tasks. Unlike traditional code-generation benchmarks (such as HumanEval), it doesn't measure "completing a function" but whether an Agent can finish a task in multi-step, tool-calling scenarios. Evaluations typically include several sub-items: codebase understanding (locating relevant code in large repositories), code modification and bug fixing (making precise changes while preserving correct behavior), terminal operations (Terminal-Bench-style tasks requiring multi-step command-line actions to reach a goal), and end-to-end project-level tasks (such as Frontier Code). Each sub-item is weighted and aggregated into a composite score. The composite score is therefore essentially an "average capability" metric that masks differences in strength across task types — which is why the evaluators recommend reading it alongside individual scores.
Million-Token Context and Four Thinking Levels
Gemini 4 Neon supports a context window of up to 1 million tokens, capable of handling large amounts of text and other types of input. The supported materials Google lists include documents, images, audio, and video.

The significance of a large context for coding Agents is that it can ingest an entire codebase, related documentation, and conversation history in one pass, reducing the information loss caused by repeated truncation and reassembly. This is especially critical for tasks that require tracing call chains across files and understanding project structure.
The model also offers four thinking levels, letting users control how much reasoning it invests in a task. This design turns "thinking cost" into an adjustable knob: simple tasks can be passed quickly at a low level, while complex tasks can be given greater reasoning depth. For teams, this directly relates to the balance between response speed and token consumption.
Thinking levels are a mechanism widely introduced by reasoning-oriented models in recent years, essentially letting the model perform internal reasoning (chain-of-thought) of varying length before generating a final answer. Lower levels reduce reasoning tokens, respond faster, and cost less, suiting tasks like format conversion and simple queries; higher levels allow the model to unfold longer reasoning chains, suiting tasks like complex bug localization and multi-constraint planning. The four-level design explicitly hands "reasoning budget" control to the caller, which is especially useful in Agent scenarios: outer orchestration logic can dynamically select a level based on task difficulty, avoiding heavy reasoning-token consumption even on simple steps. Note that higher levels don't necessarily produce better results — excessive reasoning can sometimes introduce errors instead, so in practice you should A/B test against task types.
Pricing and Availability
API pricing is $3 per million input tokens and $15 per million output tokens, with cached input priced lower.

It's important to emphasize that these are usage rates, not a fixed price per task. The bill for completing a piece of work depends on how many tokens the Agent actually consumes, including additional retry attempts. In Agent scenarios, a single task may involve multiple rounds of tool calls and failed retries, so actual costs often exceed intuitive estimates; teams should factor retry overhead into their evaluations.
Google is launching Neon through its developer and business service channels, and eligible paying users can also access it in Anti-Gravity and the Gemini app.
What to Look At Beyond the Ranking
Neon gives developers a new competitive option, which is valuable in itself. But as the evaluators suggest, testing it against the work your team actually does is more informative than looking at a single ranking.

If your team mainly understands and maintains large legacy codebases, the million-token context and scores on codebase-understanding tasks deserve more attention; if your day-to-day work centers on terminal operations and defect fixing, then individual results like Terminal Bench 4.1 and Frontier Code 2.0 — and Cloud Opus 5.5's lead on those items — shouldn't be obscured by the composite ranking.
The right approach to selection is to run a few real tasks: one that requires reading an unfamiliar repository, one that requires fixing a bug across files, and one multi-step command-line task. The results of these three small tests will be closer to your actual bill and output than any leaderboard.
Background Notes
Context window refers to the maximum total tokens a model can process in a single request, covering both input (prompts, code, documents) and output. One million tokens is roughly equivalent to hundreds of thousands of lines of code or hundreds of pages of documentation. The value of a large window lies in reducing the engineering complexity of "chunk — retrieve — reassemble": the Agent can place the entire repository structure, key files, and conversation history into context at once, avoiding the loss of cross-file dependency information due to truncation. But a large window has costs too — the more input tokens, the higher the per-call cost, and the model's attention to information in the middle of extremely long contexts may degrade (often called the "lost in the middle" phenomenon). So in practice, retrieval and summarization strategies are usually still combined with it, rather than indiscriminately filling the window.
One-line Summary
Gemini 4 Neon tops the coding Agent index, but the aggregate score blends task types — combine individual results with real-world testing when choosing.
Paragraph Summary
Google released Gemini 4 Neon, ranking first on the Artificial Analysis Coding Agent Index with 58.6, but the index blends codebase understanding, code modification, bug fixing, and command-line operations, so a single aggregate score doesn't mean across-the-board leadership. Google's comparison data also shows Cloud Opus 5.5 still leads on Terminal Bench 4.1 and Frontier Code 2.0. Neon supports up to 1 million tokens of context, handling documents, images, audio, and video, and offers four thinking levels to balance reasoning depth, response speed, and token consumption. API pricing is $3 per million input tokens and $15 per million output tokens, with cached input cheaper, but actual task costs depend on token consumption, including retry overhead. The article recommends teams run small-scale tests with real tasks before choosing.
Related articles

Gemini 4 Neon Tested in Blender: Cheap but Not the King
Bilibili creator tests Gemini 4 Neon in Blender across five rounds vs Claude Fable, Opus, and GPT. Neon's detail nears Fable but animation still lags; at $44 vs Fable's $52, cheaper Argon under $14 is the value surprise.

Gemini 4 Neon Hands-On: Can It Challenge Opus 5.5?
Google released 4 Gemini 4 models in 49 days. We test whether Neon can challenge Opus 5.5 across benchmarks, real video tasks, and subscription costs.

Former Inmate Reveals Psychopath Ratio in Prison: About 200 Out of Every 880
Former inmate Larry Lawton shares on Lex Fridman's podcast that about 200 of 880 life-sentence inmates are psychopaths—a 23% ratio. He explores the blurred line between good and evil, social dynamics in prison, and wisdom from dark experiences.