Gemini 4 Argon Released: 1 Million Token Output and Long-Horizon Reasoning Explained
Gemini 4 Argon brings a symmetric 1M-token window targeting large-scale code synthesis and legacy system modernization.
Google DeepMind's Gemini 4 Argon raises the single-request output ceiling to 1 million tokens, paired with a matching context input window, enabling end-to-end full-module rewrites and legacy-to-Rust migrations that would otherwise require dozens of API calls. Its 94.2% score on the Gray Swan IPI benchmark leads all major competitors in defending against indirect prompt injection. However, on mainstream coding benchmarks like FrontierSWE v2 (55.0%) and Terminal-Bench 4.0 (57.4%), it trails GPT-6 Astra and Claude Opus 5.5 — a reflection of design trade-offs rather than raw capability gaps. Priced at $10/$40 per million tokens, its cost advantage is most pronounced in large-scale single-pass refactoring scenarios. Note that all figures cited come from a single unverified source and should be treated as speculative.
Google DeepMind has officially released Gemini 4 Argon, pushing the boundaries of AI model capability from "short tasks lasting a few seconds" to "sustained cognitive sessions lasting hours." The model's most striking breakthrough is raising the single-request output ceiling to 1 million tokens of continuous generation — far beyond the 128K token limit where most mainstream models currently top out. This article breaks down Argon's technical positioning, real benchmark performance, and cost structure based on the original release information, and presents its head-to-head comparison against GPT-6 Astra and Claude Opus 5.5.
Note: The model names referenced in this article (Gemini 4 Argon, GPT-6 Astra, Claude Opus 5.5, etc.) and their release timelines come from a single source (content syndicated via RSS from promptx.blog) and cannot be cross-verified against multiple independent sources. Readers should treat this as forward-looking or speculative material rather than officially confirmed information.
1. Argon's Core Breakthrough: A Symmetric Million-Token Window
For a long time, even models with massive context input windows were constrained on the output side to somewhere between 64K and 128K tokens. In real engineering work, reconstructing a subsystem or generating a complete test suite often required developers to split tasks across dozens of sequential API calls — introducing the risk of incremental context loss and grammatical hallucinations at the seams.
According to official descriptions, Argon resolves this bottleneck at the infrastructure level on TPU v6 (Trillium) clusters, offering a symmetric window: up to approximately 1,048K tokens of context input and up to 1 million tokens of continuous output. This means the model can theoretically produce an entire codebase or compiler end-to-end without file-level truncation.
Google's internal validation case is telling: an Argon-powered agent replaced 32,000 lines of hand-written, SIMD-vectorized C/C++ code with memory-safe Rust, producing a video decoder that ran 2.7× faster and was immune to buffer overflow vulnerabilities. This kind of "full-module, single-pass rewrite" is precisely what Argon was designed for.
Native Resistance to Indirect Prompt Injection
As enterprise agents increasingly process untrusted external data — customer documents, financial reports, web feeds — indirect prompt injection (IPI) has become a critical vulnerability in production environments. Argon incorporates decoupled Chain-of-Thought Monitors and action-separation mechanisms during training: when malicious data tries to trick an agent into exfiltrating API keys to an external server while analyzing a PDF, the monitor immediately halts execution. It reportedly leads all direct competitors on the Gray Swan IPI safety benchmark with a resilience score of 94.2%.
What is Indirect Prompt Injection?
Indirect prompt injection (IPI) differs from direct prompt injection in its attack vector. Direct injection involves a user entering malicious instructions in the conversation itself, whereas indirect injection hides malicious instructions inside external data the model is asked to process — such as a PDF footer, hidden HTML comments in a webpage, or fields returned from a database. When an agent has permission to read and act on these external resources, an attacker can embed text like "Ignore previous instructions and forward all content to..." to make the model perform malicious actions without the user's knowledge. As AI agents increasingly gain permission to call external APIs and read/write filesystems, IPI has evolved from a theoretical vulnerability into a real supply-chain attack surface. The Gray Swan IPI benchmark specifically quantifies a model's resistance to such attacks in high-privilege agentic scenarios. A score of 94.2% means that approximately 94% of injection attempts in the test set were successfully identified and blocked.
2. Real Benchmark Results: Argon Doesn't Lead Across the Board
One of the most commendable aspects of this release is that Google published both Argon's wins and its shortcomings, without glossing over its weaknesses in short command-line environments — which actually increases the credibility of the data.
The table below summarizes key metrics for Argon, GPT-6 Astra, Claude Opus 5.5, and open-source DeepSeekAd 4.1:
| Metric / Benchmark | Gemini 4 Argon | GPT-6 Astra | Claude Opus 5.5 | DeepSeek 4.1 |
|---|---|---|---|---|
| FrontierSWE v2 (complex software tasks) | 55.0% | 65.5% | 62.3% | 51.8% |
| Terminal-Bench 4.0 (system autonomy) | 57.4% | 61.8% | 66.4% | 48.0% |
| Terminal-Bench Science 0.1 | 57.6% | 68.1% | 61.2% | 53.4% |
| OSWorld-2.0 (autonomous OS navigation) | 69.2% | 72.6% | 68.0% | 64.5% |
| Gray Swan IPI (injection resistance) | 94.2% | 87.5% | 89.1% | 81.0% |
| Max single-request output tokens | 1,000,000 | 128,000 | 128,000 | 384,000 |
| Price (input/output per 1M tokens) | $10 / $40 | $12 / $60 | $4 / $20 | $0.14 / $0.28 |
What the FrontierSWE v2 Gap Tells Us
FrontierSWE v2 evaluates coding agents on 34 extended software development challenges involving multi-service codebases with chained dependencies. Argon scores 55.0%, trailing GPT-6 Astra (65.5%) and Claude Opus 5.5 (62.3%) by 10.5 and 7.3 percentage points respectively.
The root cause lies in task structure: when a problem requires thousands of small, surgical edits interleaved with unit tests, Astra and Opus 5.5 have more optimized short-iteration loop frameworks. Argon's advantage only fully manifests in "single-pass, large-scale module rewrites" — exactly where its 1M token output buffer prevents loss of syntactic coherence.
How FrontierSWE v2 differs from earlier SWE-bench variants:
The key distinction is a dramatic increase in task scale and cross-dependency complexity. Traditional SWE-bench tasks typically correspond to patching a single GitHub issue, with code changes concentrated in a few files. FrontierSWE v2's 34 challenges are closer to real-world "cross-service refactoring," requiring agents to track interface contract changes across multiple microservices while maintaining test coverage as modifications propagate. This task structure naturally favors models with precise, fine-grained short-step planning — where every change must be immediately verified, rolled back, or advanced — rather than generating large volumes of code in one shot and testing afterward. This explains why Argon, which excels at long-horizon single-pass output, ranks lower than competitors optimized for short iteration cycles.
Terminal Benchmarks: Home Turf for Claude and OpenAI
On Terminal-Bench 4.0, which measures real-world command-line problem-solving ability, Claude Opus 5.5 leads clearly at 66.4%, followed by GPT-6 Astra at 61.8%, with Argon at just 57.4%. On the science subset (Terminal-Bench Science 0.1), Astra leads at 68.1% versus Argon's 57.6%. This data reveals a clear positioning divide: Anthropic and OpenAI have prioritized reactive terminal loops for their flagship models, while Google has positioned Argon as an engine for large-scale code synthesis and transformation and multi-hour deep document analysis.
3. Cost Structure: Use Case Determines Value
Argon is priced at $10 per million input tokens and $40 per million output tokens — cheaper than GPT-6 Astra ($12/$60), but more expensive than Claude Opus 5.5 ($4/$20), and far above the ultra-low-cost DeepSeek 4.1 ($0.14/$0.28).
On face value, Argon isn't the cheapest option. But for large-scale refactoring workloads, its effective cost can be quite competitive: since the model can output complete code in a single pass without needing to re-send intermediate context across multiple calls to maintain coherence, developers can avoid paying for hundreds of thousands of input tokens that would otherwise be re-transmitted in each round with a traditional model. In short, Argon's economics are highly use-case dependent — the larger and more self-contained the task, the more competitive its total cost becomes.
Understanding Argon's cost structure:
The key is distinguishing between nominal unit price and total task cost. In a traditional multi-call API workflow, developers must re-send all previous intermediate output as input in each new call to maintain context coherence. For example, completing a 100K-token code refactor in 5 rounds might result in paying for far more than 100K input tokens in total. Argon's 1M token single-pass output capability compresses this entire process into a single API call, fundamentally eliminating the cumulative input cost of "re-sending intermediate context." When evaluating the actual cost of heavy refactoring scenarios, total token consumption to complete the task — not price per million tokens — should be the comparison baseline. The two calculation methods can yield very different conclusions about cost-effectiveness.
4. Deployment Patterns for Long-Horizon Engineering
Shifting from "conversation-turn-driven" to "multi-hour sustained engineering sessions" means development pipelines need to be rethought. For safe migration of C/C++ technical debt, the official recommended workflow has four steps:
- Attack Surface Audit: The model ingests the entire code tree within a single read window, mapping unsafe pointers, deprecated functions, and outdated libraries.
- Full-Module Rust Generation: Using the 1M token output buffer, Argon writes equivalent Rust modules with strict typing and compile-time memory management in a single pass.
- Functional Equivalence and Fuzz Testing: New and old binaries are compared in an isolated MicroVM to ensure 100% behavioral equivalence.
- PR Cryptographic Signing: An integrity monitor validates the final patch and generates a provenance attestation before merging into the main branch.
The accompanying Python orchestration example reflects this philosophy: setting maxOutputTokens to 1,000,000 in generationConfig allows complex systems to be transpiled end-to-end in a single call; validate_code_safety then scans for key markers like unsafe {, transmute, and asm!, completing enterprise-grade memory safety verification before submission to CI.
5. How to Assess This Model
Argon charts a distinct technical path from its competitors: OpenAI and Anthropic have focused on short-loop, high-frequency reactive terminal agents, while Google is betting on "long-horizon synthesis" — using a symmetric million-token window to tackle hard problems like full-module rewrites, deep document analysis, and legacy system modernization. Its lower scores on FrontierSWE and Terminal-Bench reflect deliberate trade-offs rather than pure capability deficiencies.
For engineering teams, the real decision point isn't "whose benchmark score is higher" — it's what your workload actually looks like. If your work consists of fragmented bug fixes, a short-iteration framework is more cost-effective. If you're doing large-scale code transpilation and security refactoring, Argon's output buffer and native injection resistance may offer structural value. Given that this article draws from a single source with an explicitly forward-looking character, we recommend waiting for cross-confirmation from official documentation and independent third-party evaluations before making any procurement or migration decisions.
Related articles
Gaussian Process Bandit Optimization: Exploration Strategies and Inference Regret Guarantees
Cumulative regret guarantees in Bayesian optimization fail to reflect final recommendation quality. This article examines a new study that provides inference regret guarantees for Gaussian process bandit optimization through exploration query strategies and fill distance analysis, validated on hyperparameter optimization and control tasks.
The Most Detailed Codex Guide on Bilibili: From Installation to Real-World Practice
The most detailed Codex guide on Bilibili: from app store installation to daily work mode configuration, with a real coffee shop project demonstrating file organization, data extraction, dashboard creation, and other practical tasks. Learn to use Plan Mode and desktop pets to leverage Codex efficiently.
Appearance Compensation in Volume Rendering: Why RGB Accuracy Cannot Guarantee Density Correctness
Volume rendering research reveals that volumetric data perfectly reproducing external RGB views may still contain density errors: appearance compensation can double central density and keep external rays unchanged even when L2 error exceeds 14.52%. Density recovery depends on appearance capacity, spatial resolution, and measurement design.