TL;DR: On October 13, 2026, Google shipped Gemini 4 Argon (gemini-4-argon) — a new flagship reasoning model with a million-token context and a clear bet on autonomous agents. The headline launch case isn’t a greenfield demo: it’s an 11-hour unattended overnight run across a real 200,000-line repository. Access is limited and the rollout is bumpy; the introductory price of $2/$10 per million tokens doubles on December 1.
What the model is
From the model page in the Gemini API docs:
- Context: 1,048,576 tokens, a unified limit across input and output.
- Output: 65,536 tokens by default, up to a million in long-decode mode — the model can write very long responses without truncation.
- Input: text, images, video, audio, and PDF. Output is text only.
- Thinking levels: low / medium / high.
- Supported: Batch API (50% off), Flex and Priority inference, search grounding, code execution, computer use (preview).
- Not supported: image generation, audio generation, and the Live API. Context caching is implicit only.
Google’s positioning: complex software engineering, math and science, autonomous multi-step agents. In other words, a direct competitor to Claude Opus 5.5 and GPT-5.6 in working — not chatting — scenarios.
Access and pricing
Day-one access was predictably uneven. The model is unavailable on the free tier and on the Google AI Pro plan via the API — you need a paid Gemini API tier, or an AI Ultra subscription for AI Studio and Antigravity. The Hacker News thread on launch day shows the usual staged-rollout picture: some Pro users saw the model briefly appear and vanish, EU users didn’t have it at all, and some hit a 404 on their second request. If you’re outside Google’s subscription ecosystem, the model is already listed on OpenRouter.
Pricing, per the Gemini API pricing page at publish time:
- Introductory: $2 per million input tokens, $10 per million output, cached input at 95% off.
- From December 1, 2026: $4 input / $20 output — exactly double, and exactly the price of Claude Opus 5.5.
Two practical takeaways: you have about six weeks of half-price tokens to evaluate Argon on your own tasks, and “introductory pricing” is now a standard marketing move — always compare models on post-promotion prices.
The headline case: an 11-hour overnight run on someone else’s code
The most interesting part of the launch isn’t the logo page — it’s the engineering post about running Argon against google/adk-python, Google’s open-source agent framework: roughly 205,000 lines of Python across nearly 800 files, backed by some 17,000 unit tests.
The task was stated as an outcome, not a procedure: “make ADK add no noticeable overhead to any agent — at startup, in long sessions, in multi-agent setups. Keep the public API unchanged; back every change with a test.”
Round one — two hours, no setup. The model wrote a benchmark script seven minutes in, spent 70 minutes measuring and reading code before its first edit, and found real bottlenecks. But without repository conventions the result wouldn’t survive review: it subtly changed a public JSON schema, ran only the 216 nearby unit tests, and left benchmark numbers out of its PR description.
Round two — eleven hours overnight, unattended. Two changes to the setup: a .agents/skills directory with maintainer guidelines (short SKILL.md index files linking to detailed references, so the full rulebook doesn’t flood the context on every turn), and Antigravity’s /goal mode, which keeps the goal pinned across context compactions. Overnight, the model read 12 guideline files before touching code, ran baseline benchmarks across four workloads, and — three minutes before finishing — caught a bug in its own cache and re-ran all 16,892 tests on its own.
By morning, the pull request contained six optimizations across 32 files. After human review, two shipped:
- Filtering session history before copying, not after: the in-memory session service used to deep-copy the entire conversation on every read. That cut pre-model session-prep overhead by about 40% in long sessions.
- Lazy loading for heavy packages:
import google.adkno longer pulls in audio, video, and web server modules. Cold imports are 21% faster.
On the full 158-turn scenario, that removes nearly 10 seconds of pure framework overhead: 65.6 seconds before, 56.1 after. The other four proposals were rejected in review: a cache with a stale-data risk, a read of a private OpenTelemetry attribute, a rewrite that hurt readability with no holdout-benchmark gain, and an optimization that only helped synthetic tests. The merged commit: 22 files, 17 new tests, and the note “Argon generated these changes.”
The Google engineers’ summary is worth quoting: the agent explores, the maintainer subtracts. Honestly, that’s the most accurate one-liner about unattended runs to date.
Robotics: the second front
A companion robotics post shows Argon reasoning about the physical world. On the ERQA embodied-reasoning benchmark it scores 87% with pure reasoning — the best result among frontier models.
The demos: steering a quadruped Spot robot with practice runs in the MuJoCo simulator, zero-shot control of a robot arm via a coordinate-grid wrist camera, and building physically calibrated simulations from a single video — or even a hand-drawn sketch. The most practical number: synthetic data from a model-built simulation lifted a real robot’s success rate from 56% to 75% and cut task time from 35 to 24 seconds.
Context: release cadence and competitors
Gemini 3.7 shipped on August 13, 3.8 on September 2, and 4 Argon on October 13. Three flagship updates in two months.
After December 1, Argon sits in the same price row as Opus 5.5 ($4/$20), while GLM 5.3 offers a comparable class for significantly less. Independent day-one benchmarks are still scarce — apart from tradition, like Simon Willison’s pelican-on-a-bicycle, which Argon rendered decently, with the usual flaws (pedals not attached to the bike — judge for yourself). It’s too early to crown a “best coding model”: the first 24 hours of any launch are marketing plus anecdotes.
What this means if you work with agents
Three practical observations from the launch.
Unattended runs are now a product feature, not a hack. A /goal mode that keeps the objective pinned across context compactions, and a .agents/skills directory for repo rules, are official mechanics. If your agent toolchain lacks equivalents, the manual loop is on you.
Human review isn’t going anywhere. Two out of six is what “unattended” actually yields: a third of the proposals made it to production, and that’s presented as a success. Plan a review carousel for agent-generated changes, not “it will commit itself.”
Models will rotate every few weeks — project knowledge must live outside the model. /goal holds the objective within one run; .agents/skills hands rules to one specific tool. But your project’s decisions, bugs, and agreements belong to no run, no model, and no vendor: today you run Argon, tomorrow you’re back on Claude or evaluating GLM. That’s why we build MaxGraph — project memory as a separate layer: it lives on your machine, serves your agent a digest at the start of any session, and doesn’t care which model is this month’s flagship. Switching models stops being a migration.
How to try it
- API: model ID
gemini-4-argonon the paid Gemini API tier, available in thegoogle-genaiSDKs and on OpenRouter. - AI Studio: for Google AI Ultra subscribers.
- Antigravity: for Ultra subscribers;
/goalmode for long autonomous tasks. - Model card: deepmind.google/models/model-cards/gemini-4-argon.
FAQ
How is Argon different from Gemini 3.8? It’s a generation change, not a minor bump: flagship reasoning, long decode up to a million output tokens, and a bet on autonomous agents. Independent comparisons against 3.8 — let alone competitors — barely exist on day one.
A million tokens of context — does that make agent memory unnecessary? No. The window lives for a single session, every request with the full history is billed again, and accuracy degrades over long contexts. We measured this in tokens: external memory is cheaper and more reliable than “just a bigger window.” More in our explainer on context compaction.
Did the model really write code all night by itself? It did — with a caveat: humans accepted two of its six proposed optimizations. Autonomy currently looks like “the agent prepares, the human approves.”
Should I switch to Argon from Claude or GPT? If your pipeline is tied to a specific SDK and model-specific rules, migration costs more than the token price difference. A sane approach: run Argon on your real tasks before December 1 while pricing is halved, and compare on your own metrics — not on someone else’s tables.
What’s next
- Why your agent forgets the project between sessions: the mechanics.
- Context compaction inside long sessions: what’s lost and how to cope.
- Token economics in practice: seven ways.
Give your agent memory
7-day trial, no card. Installation is one prompt — your agent does the rest.