Gemini 4 Argon Released: One-Million Output Tokens and Self-Evolving Agents

Google DeepMind has officially released Gemini 4 Argon. In the latest episode of the Release Notes podcast, Logan Kilpatrick sat down with four core team members—Josh, Melvin, Sergey, and Tulsi—for an exceptionally information-dense conversation that revealed the new model's technical breakthroughs, internal testing details, and the self-improving flywheel Google is now building.

One Million Output Tokens: A Month of Thinking in a Single Request

Gemini 4 Argon's most striking technical spec is its industry-leading 1 million output token capability. Melvin clarified in the conversation that this is not a cumulative context length across multiple steps, but the maximum number of tokens the model can continuously output in a single inference step.

Sergey offered a vivid analogy: at a human pace of a few tokens per second, 1 million tokens would amount to over a week of continuous thinking; after accounting for sleep and daily activities, roughly a month's worth of deep thought. This means that when tackling extremely difficult mathematical proofs or open-ended reasoning problems, the model is no longer forced to interrupt its reasoning due to output window limits.

Tulsi added that at high reasoning effort, a notable share of evaluation trajectories already hit this ceiling. Previous models capped at 64K output were effectively compressing the model's reasoning ability; Argon's million-token output window truly unlocks the space for the model to "think deeply and thoroughly."

Output token limit vs. context window: A large model's "context window" refers to the total number of tokens (input plus output) the model can "see" at once within a session, while the "output token limit" refers only to the number of tokens the model can produce continuously in a single generation step. The two are often conflated. Most earlier models had output limits capped between 8K and 64K—even with a large context window, the model had to "hand in its work in installments": output a chunk, then have an external framework stitch the result back into the input to continue. This splitting is fatal for tasks requiring long chains of derivation (such as mathematical proofs or complex planning): the model loses intermediate states, repeats reasoning, or converges prematurely when switching steps. Gemini 4 Argon's 1 million output tokens mean an extremely long reasoning chain can be written in a single inference pass, and reasoning effort is no longer truncated by the output window.

Agents Join Model Training: The RSI Flywheel Starts Turning

Sergey revealed that Argon is the first version to introduce agents at scale during the model-building process. The R&D team deployed a variety of agents to monitor critical training runs, flag configuration errors, check reward scales, locate and patch bugs, and audit data duplication issues.

Melvin noted an even more telling shift: in the past, researchers asking him for compute resources would say "I need 500 chips," but now they say "I need Argon QPS"—they use the model directly to generate training data and conduct research, and the model itself is participating in building the next generation. This recursive self-improvement (RSI) loop is now genuinely running.

One impressive case: an engineer brought a long-standing hardware problem to Argon, and the model found the root cause—corrupted HBM memory from a specific vendor. When the team took this finding to the Sunnyvale hardware department, the department initially suspected it was "AI garbage," but ultimately verified and confirmed the issue, allowing the team to precisely identify and isolate all affected machines from that vendor. Sergey also recalled spending days manually diagnosing a similar memory compatibility issue years ago, marveling that the model can now complete such diagnoses instantly.

Recursive Self Improvement (RSI): This is a core concept in AI safety and frontier capability discussions, referring to AI systems participating in improving their own next-generation versions, forming a positive feedback loop of "stronger capability → more efficient improvement → even stronger capability." Traditionally, model iteration relies on human researchers to design architectures, tune parameters, and clean data; RSI hands a substantial portion of that work to agents—for example, automatically monitoring training curves, locating data contamination, generating synthetic training data, and fixing configuration errors in training scripts. Once the loop is established, iteration speed is bounded by the model's own capability rather than by human labor. The industry is both excited about RSI (accelerating research and engineering) and highly wary of it (loss of control, lagging alignment). The line in the article about "engineers no longer asking for chips but for Argon QPS" is precisely the signature signal of RSI moving from concept to engineering reality.

Writing Style Reimagined and Behavior Alignment

Argon made targeted improvements to writing quality. Josh said the team worked with professional writers, having them flag problems in model outputs and turning those into training gold standards, focusing on eliminating the "AI flavor"—excessive listing, formulaic phrases, padded expression—to make outputs more concise and precise.

On behavior alignment, Tulsi described the team's approach to finding balance across multiple axes: the model needs to be persistent enough to complete complex tasks, but not so stubborn that it fails to confirm ambiguity; it needs to show its thinking process to build trust, but not be overly verbose. Internal experiments found that users heavily view reasoning traces early after a new model launches, then gradually reduce that over time—providing product design guidance for how reasoning traces are presented in the UI. The new API already ships a more concise thinking summary feature.

Unprecedented Internal Testing: 100,000 Engineers and Safety Up Front

Josh explained that Argon underwent more than three to four weeks of internal testing before release, covering roughly 100,000 Google engineers—a scale exceeding internal testing for any previous model. The model was also handed to cybersecurity defense teams, partnering with Wiz through the Scan for Good program to identify and patch vulnerabilities in critical systems.

On the safety front, the team not only submitted the model to the U.S. government for testing but also strengthened guardrails and monitoring both inside and outside the model. Meanwhile, researchers in fields as varied as quantum computing, robotics, and science tested the model's capabilities in their own scenarios.

Practical Use Cases: From Fortran Migration to a Children's Reading App

Internal use cases showcased Argon's ability on atypical programming tasks. The Anti-gravity team used it for Fortran-to-Rust code migration—Fortran codebases still have a massive footprint in critical global infrastructure, making such migration needs real and urgent. The Chromium team is also actively using the model for development work.

Another noteworthy case came from a team member: to teach his young son to read, he had Argon build a reading-learning app. The model did not simply cobble together a quick app with pronunciation features; it first researched early-childhood learning theory, incorporated that theory into the app design, and then completed frontend development and deployment. Josh sees this as reflecting the combination of "persistence and goal orientation" in the model—building a knowledge base first, then executing the coding task, rather than generating code out of thin air.

Verification and Trust: A Required Course in the Model Era

Logan raised a practical problem: when people use Argon to complete deep investigations and send him the results, his suspicion actually increases—because the content sounds persuasive but he cannot judge whether it is true.

Sergey's advice: use AI to cross-verify AI. Models have no "ego," so using Argon to check Argon does not introduce bias, but it is best to use different models to obtain diverse judgments. Melvin emphasized actively questioning outputs—when you examine them carefully, you can often find where the model went wrong, and even if you are not a domain expert, saying "this doesn't look right" itself can drive deeper verification. Josh advised not to settle for the result of a single prompt, and to ask for the prompt to be shared and iteratively refined.

Sergey finally revealed the fundamental reasons Argon became possible: first, Google intentionally increased the pace of model iteration, forming a rapid cycle of releasing candidate versions every three to four weeks; second, there was a generational technical breakthrough between Gemini 3 and 4 that could not be scheduled. And the RSI flywheel Melvin mentioned means the model itself is becoming the core tool for building the next generation.

The principle and limits of using AI to cross-verify AI: Having another model (preferably from a different vendor with a different training data distribution) review the first model's output is essentially using "independent sampling" to reduce a single model's systematic bias. Models have no ego to protect, so they will not cling to mistakes out of face like a human reviewer—that is their advantage. But this method is not a panacea: if both models share similar training corpora or similar error patterns, cross-verification may be "wrong together, right together"; moreover, the verifier model itself can be misled by persuasive language in the input (so-called "sycophancy bias"). In practice, therefore, three things should be done—switch models, switch prompts, switch angles; treat the model's output as a hypothesis to be verified rather than a conclusion, and combine it with authoritative first-hand sources for the final judgment.

One-line Summary

Gemini 4 Argon launches with one million output tokens and agent-assisted training, kicking off a self-improving model flywheel.

Paragraph Summary

Google DeepMind released Gemini 4 Argon, whose core breakthrough is an industry-leading 1 million output tokens—a single inference can complete what amounts to a month of human deep thinking. More importantly, Argon is the first to introduce agents at scale into model building, using them to monitor training, fix bugs, and audit data, so the model begins to participate in building the next generation and the recursive self-improvement (RSI) flywheel starts turning. About 100,000 Google engineers participated in internal testing before release, and the team partnered with Wiz to patch critical vulnerabilities. Writing style was reshaped by professional writers to eliminate "AI flavor," while behavior alignment balances persistence, transparency, and concision. The model also demonstrated capability in atypical tasks such as Fortran-to-Rust migration, a children's reading app, and hardware root-cause diagnosis. The team stresses that using AI to cross-verify AI is a required course in the model era.