
Google dropped a new AI model on November 18, and it is aimed squarely at people who write code for a living. Gemini 4 Neon is the fourth member of the Gemini 4 family, and it sits between Carbon, the heavyweight built for the hardest long jobs, and Hydrogen, the fast everyday helper.
The pitch is simple. Neon keeps most of Carbon’s brainpower, finishes jobs faster, and costs less per finished task. Google’s announcement says it ranks third overall on the Artificial Analysis Intelligence Index with a score of 61, and first on the same firm’s Coding Agent Index. Those are Google’s reported numbers, and they come with the usual caveat that launch benchmarks are picked by the company doing the launching.
So what actually changes for you? Nine changes, grouped into seven shifts below. Some of them will change what you pay. Some will change how you work. One of them is a separate security tuned model most people will never touch, and it still matters. Here is the full picture, with every number checked against Google’s announcement and the independent write-ups that followed it.
Neon is adapted from Gemini 4 Carbon, according to the model card, so this is not a brand new brain built from scratch. Think of it as Carbon tuned for speed and for the kind of repeated, high frequency work that developers and analysts do all day. That tuning is the whole story, and it shows up in the price, the speed, and the way the model handles long jobs.
1. It Finishes Whole Coding Jobs, Not Just Single Files

Most coding models are good at one file at a time. You paste a function, you get a function back. Neon is built for the job after that, the long messy one where a fix touches twelve files, three tests break, and the model has to keep going without losing the thread.
Google engineered it for long running agent workflows, which is a fancy way of saying it can plan a task, call tools, read files, run checks, and revise its own work until the job is done. It sustains performance through complex, tool heavy tasks from start to finish instead of fading halfway through. That matters because real coding work is rarely one clever answer. It is a chain of small steps, and a weak link anywhere in the chain ruins the result.
The practical details are encouraging. Neon cuts down on redundant file reads, so it wastes less of your context window re-reading code it already saw. It shares progress as it works, so you can see what it is doing instead of staring at a spinner. It handles context compaction reliably in long sessions, which means it can shrink older conversation history to make room without forgetting the plan. And when it fixes a bug, it makes targeted, surgical edits across repositories instead of rewriting whole files.
For production code, that last point is the one to watch. A model that rewrites everything it touches creates review work for humans. A model that changes only what needs changing saves it.
2. It Remembers Your Entire Project and Writes Much Longer Answers

Neon carries a 1 million token context window, and that number deserves a plain explanation. A token is a small chunk of text, roughly three quarters of a word. A 1 million token window means you can feed the model an enormous amount of material at once: a whole codebase, a stack of documents, spreadsheets, PDFs, charts, audio, and video, all in one conversation.
The window is unified, which means input, reasoning, and output all share the same budget. Neon accepts text, images, audio, and video as input and replies in text. For knowledge work, that means you can drop in a quarter of financial reports, a product spec, and a recorded meeting, then ask for one structured deliverable that draws on all of them. Google says Neon synthesizes across all of these inputs in a single window and turns them into structured reports, summaries, and plans.
The output side got bigger too. A normal response can run up to 64,000 tokens by default, which is a very long answer, roughly 48,000 words if you ever needed it. A background long decode mode can stretch output up to the full 1 million token window for the rare jobs that need it, like generating a huge report or a large codebase in one pass. Most people will never hit that ceiling. The point is that the ceiling is no longer the thing that stops you.
3. It Costs Less Per Finished Task Than Carbon

Here is the number most developers will care about first. Neon costs $3 per million input tokens and $15 per million output tokens on the paid Gemini API tier. Cached input, which is text the model has already seen and stored, costs $0.15 per million tokens, a 95 percent discount.
But the per token price is only half the story. Google says that at its default high thinking level, Neon costs 32 percent less per completed task than Carbon. Artificial Analysis measured the gap independently and found about 17 percent lower cost per task, with Neon at $6.44 per task against $7.76 for Carbon at standard pricing.
There is a timing twist worth knowing. Carbon is currently on promotional pricing of $2 input and $10 output per million tokens until November 30, 2026. Until that date, Carbon is actually cheaper per token than Neon. From December 1, Carbon rises to its standard $4 and $20, and Neon becomes 25 percent cheaper per token without moving at all. If you are budgeting a project that starts now and runs into December, that switch date matters more than today’s sticker price.
Speed helps the math too. Artificial Analysis measured Neon at roughly 110 output tokens per second, about double Carbon’s 57. Faster output means shorter waits, and for agent work it means a long job finishes in about 21 minutes instead of Carbon’s 36.
4. It Tops the Coding Scoreboards That Actually Matter

Benchmarks are easy to overrate, and Google picked the ones in its launch post. Still, the spread is worth a look, because Neon leads on the tests that mirror real developer work rather than trivia quizzes.
The headline score is 61 on the Artificial Analysis Intelligence Index at the highest xhigh thinking level, which puts Neon third overall, just behind larger and slower models. On the Artificial Analysis Coding Agent Index it ranks first overall at 58.6. That index measures how well a model acts as a coding agent, doing multi-step work with tools, not just answering questions about code. Through the Antigravity command line tool, Artificial Analysis measured 59, three points ahead of Carbon.
The coding specific results back it up. Neon scores 65.2 percent on Terminal-Bench 4.1, a test of real terminal tasks, and 46.2 percent on FrontierCode 2.0 at its default high setting. On the Vals Index, which tests enterprise agent work, it ranks second at 70.9 percent and takes first place on both the legal research and tax agent benches. It also debuts second globally on the Agent Arena Index with 1,336 points across more than 4,200 real agent sessions, and ranks second on steerability, which measures whether a model adjusts cleanly when you correct it mid-task.
Keep one caution in mind. Every figure above is either Google’s own account or a third party index Google chose to highlight. Independent tracking was still incomplete at launch. Treat the scores as a strong early signal, not a final verdict, and watch how Neon performs on your own codebase before you switch a production workflow to it.
5. It Can Run a Team of Faster Helpers While It Supervises

The most interesting change may be how Neon works with other models. Inside Google Antigravity, the company’s agentic coding environment, Neon can run alone or act as an Orchestrator, a high judgment boss that directs parallel Hydrogen subagents. Hydrogen is the fast, cheap member of the Gemini 4 family, built for quick everyday execution.
Picture the workflow. You give Neon a big job, like migrating a feature across a codebase or auditing a service for bugs. Neon breaks the job into pieces, hands each piece to a Hydrogen subagent, checks the results, and stitches everything back together. You get Carbon level judgment steering the work and Hydrogen level speed doing the bulk of it. Google says Neon shares progress as it works in this mode, so you are not left guessing what the team is doing.
Neon also gives you finer control over how hard it thinks. It offers four thinking levels, low, medium, high, and xhigh, with high as the default. A thinking level is simply how much reasoning the model does before answering. Low is fast and cheap for simple jobs. Xhigh is slow and thorough for the hardest engineering and scientific work, and it is where Neon posts its best intelligence score. The levels scale steadily, so you can dial intelligence and token spend to match each workload instead of paying flagship prices for a trivial task.
For teams, this is the practical win. Routine refactors run cheap and fast, while the one genuinely hard problem of the week gets the full xhigh treatment.
6. It Says Yes More Often and Shrugs Off Hidden Instructions

AI coding agents touch real systems, so safety is not an abstract concern. A model that runs commands, reads emails, and edits files needs to refuse dangerous requests, follow your instructions rather than instructions hidden in a web page, and stay inside the scope you gave it. Neon moves all three in the right direction, according to Google’s internal tests.
Start with hidden instructions, known as indirect prompt injection. That is when malicious text is planted in a web page, email, document, or code the model reads, trying to trick it into doing something you never asked for. On Gray Swan’s benchmark for this attack, Neon resisted every attack at its highest thinking level with real time safeguards on, matching a 0.0 percent attack success rate.
Then there is the opposite problem: models that refuse legitimate work out of caution. Google says Neon declined far less legitimate work than Carbon in these areas, refusing just 1.98 percent of tasks on Terminal-Bench 4.0 and 0 percent on Terminal-Bench Science. In its agentic behavior tests, under-service fell 43 to 56 percent and overreach fell 15 to 35 percent across effort levels.
The discipline numbers are strong too. Neon recorded a 0.09 percent misaligned action rate and a 99.2 percent pass rate on the agent honesty evaluation. It matched Carbon with 0.0 percent cheating on Terminal-Bench 4.0 and took shortcuts on just 2.45 percent of tasks on a coding cheating test, the lowest rate of any Gemini 4 model. Google also says Neon recorded its lowest fabrication rate yet in internal Antigravity testing, which means fewer invented facts in its answers.
7. It Ships a Security-Hardened Twin, and It Is Already in Your Tools

The last two changes come as a pair. First, there is a separate variant called Gemini 4 Neon for cyber, built for defensive security work. It produces more secure code than Carbon across easy, medium, and hard challenges on AutoBaxBench, reaching state of the art on the hard tier at 76 percent. It also leads on finding vulnerabilities, scoring 90.5 percent on SEC-bench Pro, and on fixing them, reaching 70.7 percent on CWE-bench v2. On WebExploitBench, a penetration testing benchmark, it is state of the art at 51.26 percent while costing about half as much as competing large models.
Most readers will never use the cyber variant directly. It is rolling out to trusted defenders over the coming days as part of Google’s Fairwind Program, and access goes through a Google Cloud account team.
Second, Neon is already available in the tools you probably use. It is rolling out in the Gemini API paid tier in Google AI Studio and Android Studio, in Gemini for business through the API and the model dropdown, in Google Antigravity for paid Google AI Pro and Ultra subscribers, and in the Gemini app for Pro and Ultra subscribers. The model ID is gemini-4-neon. One gap to note: Neon is not available on the free API tier, and Google’s launch post makes no mention of Vertex AI, so enterprise teams on Google Cloud will need to wait for a separate update.
Neon is not a revolution. It is a refinement, and refinements are exactly what working developers need. It does the same jobs Carbon does, faster and cheaper, with a bigger memory, longer answers, fewer refusals, and stronger defenses against the tricks that target agents.
The smart move is to try it on a real job this week, not a demo. Pick a multi-file refactor you have been putting off, or a research task that needs a dozen sources pulled together. Watch the cost per finished task, not the cost per token, and remember the December 1 price switch before you lock in a budget. Your own codebase will tell you more than any benchmark.
