
Gemini 4 Neon in Antigravity: 762 Tool Calls at a 512K Ceiling
- OrcaNEWOrcaCyber: Hy4 Flash Abliterated / Uncensored2026-11-18$0.07 / $0.28 per 1M tokens · 188 tok/s
- tencentNEWTencent: Hy4 Flash2026-11-16$0.02 / $0.07 per 1M tokens · 205 tok/s
- GoogleNEWGoogle: Gemini 4 Carbon2026-11-10$2.00 / $10.00 per 1M tokens · 87 tok/s
- AnthropicNEWAnthropic: Claude Fable 5.22026-11-09$8.00 / $40.00 per 1M tokens · 97 tok/s
- orcaNEWOrca: OrcaC2 1.02026-11-079 tok/s
- OrcaOrcaCyber: GLM 5.3 Abliterated / Uncensored2026-11-04$3.00 / $5.00 per 1M tokens · 90 tok/s
- OrcaOrcaCyber: Hy4 Abliterated / Uncensored2026-11-04$0.80 / $1.60 per 1M tokens · 131 tok/s
- OrcaOrcaCyber: Kimi K3.1 Pro Abliterated / Uncensored2026-11-04$2.00 / $5.00 per 1M tokens · 77 tok/s
- tencentTencent: Hy42026-11-04$0.83 / $2.50 per 1M tokens · 125 tok/s
- OrcaOrcaCyber: MiniMax M3.1 Flash Abliterated / Uncensored2026-10-29$0.80 / $1.60 per 1M tokens · 114 tok/s
- OrcaOrcaCyber: GLM 5.3 Flash Abliterated / Uncensored2026-10-27$0.80 / $1.60 per 1M tokens · 66 tok/s
- OrcaOrcaCyber: Qwen3.8 Flash Next Abliterated / Uncensored2026-10-26$0.80 / $1.60 per 1M tokens · 94 tok/s
- OrcaOrcaCyber: MiMo V2.6 Flash Abliterated / Uncensored2026-10-26$0.80 / $1.60 per 1M tokens · 41 tok/s
- MoonshotMoonshotAI: Kimi K3.1 Pro2026-10-2447Intelligence
- OrcaOrcaCyber: DeepSeek V4.1 Flash Abliterated / Uncensored2026-10-23$0.80 / $1.60 per 1M tokens · 210 tok/s
- minimaxMiniMax: M3.1 Flash2026-10-1929Intelligence
- OrcaOrca: OrcaCyber Ultra 1.02026-10-17$5.00 / $10.00 per 1M tokens · 110 tok/s
- deepseekDeepSeek: DeepSeek V4.1 Flash 10172026-10-1733Intelligence
- DeepSeekDeepSeek: DeepSeek V4.1 Flash 09102026-10-17$0.15 / $0.60 per 1M tokens · 95 tok/s
- DeepSeekDeepSeek: DeepSeek V4.1 Flash2026-10-1740Intelligence
Thirteen sessions, 762 tool calls, and one number that does not appear anywhere in Google's launch material: 512,000. That is the context window Antigravity's own documentation gives Gemini 4 Neon, against the 1,048,576 tokens the Gemini API sells for the same model at $3.00 in and $15.00 out. Both figures are Google's, published the same week, and neither page mentions the other. The tool-call log comes from a hands-on thread that @kimmonismus published on 18 November 2026, thirteen and a half hours after Antigravity's Neon post went up and thirty-five minutes after DeepMind's, which is to say the model he describes having "early access" to was already generally available when he hit publish.
That timing matters for how much weight to put on the thread, not for whether it is useful. It is the most detailed public account anyone has published of Gemini 4 Neon doing sustained agentic work, and the interesting part is not the demos. It is the shape of the log, which is checkable arithmetic in a way that "it built 17 interactive demos" is not.
The 762 calls, broken down
The poster went back through Antigravity's logs after the fact and tallied every call across those thirteen sessions, all run at the Extra High thinking level. The breakdown, self-reported and unaudited:
• File reads — 313
• Edits — 266
• New files created — 104
• Shell commands — 43
• Sub-agents spawned — 13
• Web searches — 2
• Other calls, including task updates — 21
Those sum to 762 exactly, which is the first thing to check and the first thing that holds. Divide by thirteen and you get roughly 58.6 tool calls per session, a figure that lands suspiciously close to the 58.6 Neon scores on the Artificial Analysis Coding Agent Index — coincidence, but a memorable one if you are trying to hold both numbers in your head.

The more informative ratio is the one Google's own positioning invites you to test. The launch post claims Neon "cuts down on redundant file reads" and "handles context compaction reliably in long sessions." In this log, reads are 313 of 762 calls, or 41%. Writes — 266 edits plus 104 new files, 370 calls — are 48.6%. That is 1.18 write operations for every read. A model that was thrashing through a codebase trying to locate things would show the opposite ratio; a model that already knows where it is going reads once and writes. One user's thirteen sessions is not evidence of a general property, but it is the direction the claim predicts, and it is the only public log of the claim being exercised.
The two numbers that look oddest are sub-agents and web searches. Thirteen sub-agents across thirteen sessions is exactly one per session — a consistent delegation pattern rather than an occasional one. Two web searches in 762 calls is 0.26%, which for a model Google describes as an orchestrator directing parallel Hydrogen subagents is remarkably inward-facing. This was a run against local code, not research, and the log reflects that.
What the demo run actually shows
Seventeen interactive demos, eight of them shown. The eight visible ones span a 3D arena shooter with enemy waves, health, ammo and reload; a rail shooter called Solaris Trench; a destructible voxel arena called Terra Breaker that held a steady 60 frames per second in a browser test; a jet-through-canyon game called Aero Canyon with twelve gates and a saved best time; a physics puzzle with levers and a ball launcher; a particle-field light show; a black-hole flyby with adjustable lensing; and a clickable solar system.
The nine that were not shown are the part of the thread that cannot be evaluated, and the honest reading of "17 demos" is that it is a claim about volume with eight samples attached. What the eight samples do establish is breadth: a single model producing WebGL scenes, physics, audio-driven visuals and UI state management in one sitting, at a quality a hobbyist would post. That is a real capability signal even if the count is unauditable.
The failure modes the poster reported are more useful than the successes, because they are specific. The first build of the 3D arena "broke off on a server error" and needed a second pass to finish — an infrastructure failure, not a model failure, but one that cost a full attempt. Neon added an autopilot mode to Aero Canyon that was never requested, which the poster flagged as unasked-for scope. He then only tested the autopilot, so manual flight quality remains unknown even for a demo he built. The solar system shipped with outdated moon counts and was corrected to JPL's current numbers only after he flagged it; sizes and orbits are still not to scale.
That last one is the most interesting data point in the thread, because it is a clean demonstration of mid-task correction: a factual error, flagged by the user, repaired in a follow-up. Google claims Neon ranks second on steerability on Arena's new Agent Arena Index. One anecdote does not confirm a leaderboard position, but it is the behaviour the leaderboard claims to measure, observed in the wild.
Three bug fixes, self-graded
The coding section is three broken programs with existing test suites, each fixed and then verified by the poster himself rather than by the model's own report.
• Booking checker — 1 of 5 tests passing before, 5 of 5 after.
• Task scheduler — 8 of 14 checks before, 14 of 14 after.
• Async loader — 10 of 16 checks before, 16 of 16 after.
Aggregate: 19 of 35 passing before, 35 of 35 after, or 54.3% to 100%. A perfect score is the number to be suspicious of, and the honest caveats are all on the sample rather than the result. Three programs is three programs. The test suites were pre-existing, which removes the obvious failure mode where a model writes tests to match its own fix, but it does not remove selection: these were programs the poster chose to bring, and a fix that resolved the visible failures could still be wrong in ways the suite does not cover. What the run does show is that the model did not regress anything while fixing — 35 out of 35 means the previously passing tests kept passing, which is the failure mode that actually bites in practice.
Antigravity gives Neon 512K, not 1M
Now the number that is not in the thread and should change how you read the rest of it. Antigravity's model documentation, on the Gemini 4 Neon entry, states the context window as "up to 512K tokens." The Gemini API documentation for the same model states a unified 1,048,576-token window, and Artificial Analysis lists 1,000,000 for the model. Same weights, same rate card, roughly half the context, depending on which surface you call it from.

Google has not published an explanation for the gap, and this piece is not going to invent one. What is verifiable is that the two numbers are both live, both Google's, and both attached to the model code gemini-4-neon. The practical consequence is straightforward: if your evaluation of Neon is "it holds a large monorepo in context," that evaluation is surface-dependent. A 600,000-token repository fits in the API and does not fit in Antigravity. If you are deciding between the two, measure at the surface you will actually ship on, because the ceiling is not the same one.
The rest of the Antigravity picture is more conventional. Neon is the default model for new conversations on every plan that includes it — paid Google AI Pro, Google AI Ultra, and Gemini Enterprise. It is not on Free or Google AI Plus. The thinking ladder runs Low, Medium, High (default) and Extra, with the CLI spelling them low, medium, high and xhigh via --model gemini-4-neon-xhigh or --effort xhigh. The thread ran entirely at Extra High, which is the setting Google itself uses for its headline Intelligence Index figure, and the one the API documentation recommends reserving for hard multi-step problems.
That is worth flagging as a sourcing asymmetry rather than a flaw. Nearly every Neon benchmark number in circulation — the 61.4 Intelligence Index, the 58.64 Coding Agent Index — is an xhigh number. Most people will run the model at its default High. Artificial Analysis does publish both, and the default figure is 59.6, three full points below the headline. A 762-call log at xhigh tells you what the ceiling looks like; it does not tell you what your default configuration will cost or score.
Where the thread overreaches
Three claims in the thread do more work than the evidence supports, and they are worth naming because they will be repeated.
The "early access" framing is the clearest. Antigravity's own blog post on Neon published at 08:00 UTC on 18 November 2026; DeepMind's launch post at 21:00 UTC; the thread at 21:35 UTC. Whatever access the poster had earlier in the day, the piece he published landed after general availability, and reading it as a pre-launch preview would be a mistake. That does not make the observations wrong. It does mean "I got early access" is doing rhetorical work the timestamps do not support.
Second, "17 interactive demos" is a volume claim with eight exhibits. The eight shown are genuinely varied and genuinely working, which is the useful part. The nine withheld are unauditable, and no amount of detail about the eight closes that gap.
Third, the 35-out-of-35 fixing result is a result about three programs. It is the kind of number that gets quoted as "Neon fixes everything you give it," and the correct reading is narrower: on three pre-broken programs with existing suites, it resolved every failing check without breaking the passing ones. That is a good outcome and a small sample, and both halves of that sentence need to travel together.
One piece of corroboration is worth noting. Patrick Loeber, a member of technical staff at Google DeepMind, replied to the thread: "nice thread, thanks for building with it and sharing your feedback!!" That is not a verification of any number in it. It is a Googler acknowledging the run happened, which is more than most hands-on threads get.
What it costs to try this yourself
The economics of a field test like this are unglamorous and decisive. At $3.00 per million input tokens and $15.00 per million output, a 762-call session with heavy context reuse is not a $5 experiment — the output side, including thinking tokens, dominates, and xhigh multiplies it. Google's own framing is that Neon at its default High setting costs about 32% less per task than Gemini 4 Carbon (vendor-reported, not independently reproduced), and that the xhigh setting is for problems where High falls short. Running a demo suite at xhigh when you were evaluating default behaviour is a way to spend several times what the decision required.

The cheaper way to run this evaluation is to fix the surface and the thinking level first, then vary the model. On our side the catalogue currently carries google/gemini-4-carbon and google/gemini-4-argon, both at the provider's $2.00 and $10.00 list price with 0% markup on top — a vendor rate change is live on our side the same day it lands upstream, which matters here because Carbon's introductory rate expires on 30 November 2026 and steps to $4.00/$20.00. Gemini 4 Neon is not in the catalogue as of 19 November 2026, so this is not a recommendation to call it through us; it is the comparison you can actually run today, against the model Google benchmarks Neon against in almost every paragraph of its announcement.
If you are testing an unproven model rather than a known one, the routing layer is also the cheap place to bound the risk: automatic failover means a session that dies mid-run — the way the first 3D arena build did — can be retried on a different model without rebuilding the harness, and the routing DSL lets you compose a planner and an executor into one call if you want to reproduce the Orchestrator (Neon) pattern without being locked to Antigravity's 512K ceiling.
What to watch
The next piece of evidence that would settle the open questions is not another demo thread. It is a tool-call log from someone running at the default High setting, on a repository large enough to press against whichever context ceiling applies, published with the failures left in. The 512K-versus-1M gap is the specific thing to watch, because a documentation discrepancy that survives a release cycle is usually a product decision rather than an oversight — and if Antigravity is deliberately halving the window, that is a fact worth knowing before you standardise a workflow on it.
Until then, the fair summary of Gemini 4 Neon in Antigravity is this: one detailed public log, thirteen sessions deep, showing a model that writes more than it reads, delegates once per session, fixes three small programs perfectly, builds eight good demos out of a claimed seventeen, and runs at roughly half the context the API advertises. Every one of those clauses is checkable. None of them is a benchmark.
