Google's Gemini Argon Turns the Chat API Into a Job Queue

The million token output is really sixty four thousand token hops, stitched together server side. That changes your cost, timeouts, and context math.

SnackOnAI Engineering | Senior AI Systems Researcher | Technical Deep Dive | October 16, 2026

The promise: by the end of this issue you will understand how Gemini 4 Argon's unified 1M token window and long decode actually work, what a million token job really costs, and where Argon leads and trails its rivals.

The fence: we cover the gemini-4-argon model in the Gemini API, its launch post, its developer docs, the Interactions API, the Antigravity managed agent, and Google's disclosed benchmarks. We skip the consumer Gemini app, the Fairwind cyber program beyond its safety numbers, and Argon's internals, which Google has not published.

Gemini 4 Argon is Google's first Gemini 4 model and its first new flagship since the Gemini 3 series in November 2025. It was announced September 30 to trusted testers and opened to paid Gemini API developers on October 13, 2026.

What developers actually get:

The strongest numbers are third party scored business evals: Vals Index 68.9% (Opus 5.5 67.0, GPT-6 Astra 63.1), AutomationBench 51.3%, Vals Finance Agent 65.4%, Harvey Legal Agent 19.6% versus 5.4% for GPT-6 Astra and 3.8% for Opus 5.5. Long context retrieval is a standout: GraphWalks 256K to 1M at 84.2%, against 71.8% and 66.8%.

The honest one line summary: a frontier model tuned for long, multi step professional work, shipped with an API built for jobs rather than chats.

Google has disclosed nothing about Argon's model internals: no parameter count, no MoE details, no attention design. What it has disclosed is the serving architecture, and that is where the engineering story lives.

Caption: Focus on the hop loop. A "1M output" is a chain of 64K generations, each re-reading the growing transcript, which is why implicit caching and polling are now part of the API contract.

Three decisions matter, ranked.

One: a unified window instead of separate input and output caps. Claude Opus 5.5 has a 1M context and a separate 128K output cap. Argon has one 1M pool. Google's September announcement called it a 1M output cap; the shipped docs describe a shared budget. An 800K token codebase prompt leaves only 248,576 tokens for thinking and answer combined.

Two: long output as a background job. Anything beyond 64K requires background: true. The client gets an ID, polls, and stitches model_output steps. Google recommends client timeouts of at least 15 minutes. The chat completion abstraction, one request in and one response out, no longer holds at the top end.

Three: Google took the sampling knobs away. temperature, top_p, and top_k are silently ignored. The only lever left is thinking_level. That is a strong opinion: for a reasoning model, compute budget matters more than randomness.

First, the long decode pattern, from Google's own docs (Apache 2.0), with our annotations.

Caption: Three production bugs live in this snippet if you skip the comments: blocking clients that time out, reading one step instead of all of them, and treating summed usage as context size.

Second, the context accounting trap. Agent harnesses usually compact history when token usage nears the window. With hops, the usage number lies. Developers testing the protocol found that total input is "the sum of every hop's input, not the size of your context." Here is the naive check against the correct one.

Caption: Billed input across four hops is 1.99M tokens for a context that never exceeds 662K. Compaction logic must read the initial prompt count, not the usage total.

Third, the cheapest migration you will ever ship, per Google's checklist:

Caption: Two items on this list fail silently: a leftover temperature does nothing, and a leftover low output cap truncates thinking and answer together.

Input: a 600,000 token monorepo dump plus the instruction "Produce a full migration plan and patched files for moving our payments service from callbacks to async/await." Settings: thinking_level="high", max_output_tokens=262144, background=True.

Step one, fit check. 600,000 + 262,144 = 862,144 tokens, under the 1,048,576 window. An 800K prompt with the same output cap would be rejected; it leaves only 248,576.

Step two, hops. 262,144 / 65,536 = 4 hops. Each hop re-reads the prompt plus prior output: 600,000, 665,536, 731,072, and 796,608 input tokens, 2,793,216 in total.

Step three, cost. Assuming each hop's repeated prefix hits the implicit cache (our assumption, based on the documented 95% discount for repeated hop input):

Step four, wall clock. Google says hard prompts can take several minutes and recommends 15 minute client timeouts. The client polls every 5 seconds and receives four model_output steps.

Output: one migration plan of up to roughly 262K tokens of thinking plus answer, for about $4 at intro prices. Cache behavior alone moves the bill by 2x.

Caption: The most expensive line item is not the million token window. It is re-reading a long prompt every 64K tokens of output when the cache misses.

Why it works. Long agentic tasks fail when a model runs out of output budget mid plan. Hopping in 64K chunks lets Google serve very long generations without pinning one request for its whole duration, and checkpointing each hop makes failures resumable. Server side state (previous_interaction_id) keeps tool calls and multi turn history off the client. Killing temperature removes a whole class of "it worked yesterday" variance from agent pipelines.

What it trades away.

The moat is serving long, stateful decodes at a price of $2 in and $10 out. At intro pricing Argon costs about one fifth of GPT-6 Astra ($10 and $50) and half of Opus 5.5 ($4 and $20); after November 30 it matches Opus 5.5. Running 64K hops with 95% cache discounts on re-read prefixes, across 1M token contexts, is an infrastructure capability few providers can price this way.

The second moat is distribution into work. More than 100,000 Googlers use Argon monthly through an internal Antigravity build. Over four weeks, agent submitted code rose 35% and post submit rollbacks fell 30%, per Google. That is a feedback loop from real engineering work that a lab without a giant internal codebase cannot buy.

The third is safety at agent scale: 0.7% attack success on Gray Swan's indirect prompt injection test after 15 adaptive attempts, versus 1.0% for Opus 5.5 and 8.5% for GPT-6 Astra. For agents that read untrusted web pages and email, that number matters more than most capability scores.

Insight One: Argon leads where work looks like documents, and trails where work looks like terminals. Third party evals on finance, legal, and business automation favor Argon by wide margins. But on Terminal-Bench 4.0 it scores 57.4% against Opus 5.5's 66.4%, on FrontierSWE v2 55.0% against GPT-6 Astra's 65.5%, and on Artificial Analysis's Intelligence Index it sits at 53 against Opus 5.5's 58. Bloomberg reported Google employees found it weaker on some front end coding work. For autonomous coding agents, this is not yet the obvious default.

Insight Two: the benchmarks were run at a setting most users won't pay for. Google reported Argon at its highest thinking level, and some rival scores came from leaderboards or rivals' own reports. The API default is medium, and Google itself advises picking the lowest level that passes your evals. Thinking tokens bill as output at $10 to $20 per million. Expect a gap between leaderboard Argon and production Argon unless you budget for high.

Argon's "million token output" is not one long generation. It is up to sixteen generations of 64K tokens, each re-reading everything before it. A 262K token answer on a 600K prompt bills 2.79M input tokens across four hops, even though the context never exceeds 862K. The unified window is the honest limit, but the bill, the latency, and your agent's compaction logic all follow the hop count, not the window.

Imagine hiring a consultant who can read your company's entire archive in one sitting and then write a report as long as a novel. That is the promise of Google's new model, Gemini 4 Argon.

Until now, most AI assistants worked like a quick conversation. You ask, they answer within seconds, and there is a limit to how much they can write in one reply. That is fine for questions, but not for real projects like auditing a codebase or drafting a legal analysis that runs hundreds of pages.

Argon changes the shape of the interaction. For big tasks, you hand it the job and it works in the background, writing in chunks and picking up where it left off, while your software checks in every few seconds. It is less like texting a colleague and more like submitting a request to a team that emails you when the deliverable is ready.

There is a catch. The model has one shared budget for everything it reads and everything it writes. Give it a giant pile of documents, and it has less room left for its answer. Long jobs also cost more than the headline price suggests, because the model rereads its own work as it goes.

This matters because AI is shifting from answering questions to doing assignments. The companies that win will be the ones whose software can handle work that takes minutes, not milliseconds.

Gemini 4 Argon's benchmark wins in finance, legal, and long context retrieval are real, and its prompt injection resistance is the best disclosed. But the lasting change is the API. A shared million token pool, 64K hops, background polling, server side state, and no temperature knob describe a job runner, not a chatbot. Teams that treat Argon as a drop in replacement will hit timeouts, truncated answers, and phantom compaction. Teams that rebuild their harness around jobs will get frontier long horizon work at a fraction of the price, at least until November 30.