On October 13, 2026, Google made Gemini 4 Argon generally available, its new top-tier AI model. Until now, it had been offered only to a limited group of security professionals. It is now open to developers, enterprises and paid subscribers of the Gemini app. Its defining feature is the ability to sustain complex reasoning over long periods, and Google says it excels at multi-step work such as large-scale code changes and specialized research. There is a catch, however: the maximum capacity of 1 million tokens is shared not only by input but also by internal reasoning and the final answer. A real-world development case published by Google also shows that handing AI long-running tasks depends not just on model performance but also on cost management and a way to verify the results.
Gemini app open to Pro subscribers; developer tools mainly for Ultra and paid API users
Gemini 4 Argon was announced on September 30. At first, it was available only to vetted security professionals participating in Google's "Fairwind Program."
With this release, it can be used beyond the security field. That said, the performance shown in the September preview has not been further improved to coincide with general availability.
Availability and contract terms differ by product.
Based on Google's general availability announcement, its developer guide and its Google Cloud announcement, the main channels are as follows.
| Service | Eligible users / conditions |
|---|---|
| Gemini app, AI Mode in Google Search | Google AI Pro and Ultra subscribers |
| Google Antigravity, subscriber features in AI Studio | Google AI Ultra subscribers |
| Gemini API for developers | Paid API tier; available via AI Studio and Android Studio |
| Enterprise services | Gemini for business, Gemini platform APIs, etc. |
Regions, languages and service-specific restrictions still need to be checked separately. Just because Google announced a worldwide rollout does not mean every account can use it at the same time.
One point deserves particular attention: Google AI Pro subscribers being able to use Argon in the Gemini app is not the same as the same plan covering the API and developer tools.
Google's API terms state explicitly that Argon is not supported on the free API tier or on the Google AI Pro tier for developers.
Meanwhile, the Gemini app itself is evolving from a service that simply answers questions into an environment where AI actually carries out work.
In the new Gemini app, switching from a regular conversation to a "task" lets the AI keep working even while the user is away from the computer.
Google describes integrations with more than 40 apps, and the macOS version also embeds Antigravity's coding screen.
The Gemini app announcement suggests that Google is prioritizing not only the accuracy of answers but also the AI's ability to operate apps and get real work done.
Up to 1 million tokens of reasoning: how much can you actually use?
A major feature of Gemini 4 Argon is its context window of up to 1,048,576 tokens, commonly called "1 million tokens."
A token is the unit an AI uses to process text or code, and it does not necessarily match the number of characters or words.
What matters is that this 1 million tokens is not capacity reserved for input; it is shared among input, internal reasoning and the final answer. Information related to function calls also counts toward this limit.
Google's technical documentation on long-running reasoning and output generation explains this mechanism in detail.
For example, if you input 200,000 tokens of code or documents, the remaining capacity is as follows:
1,048,576 − 200,000 = 848,576 tokens
These roughly 850,000 tokens can be used for internal reasoning, the final answer and so on.
In other words, you cannot load 1 million tokens of material and then also generate a 1-million-token answer. The more code or material you input, the less capacity the model has left to think and generate a response.
Previously, output per call was capped at 65,536 tokens.
With Argon, reasoning and output beyond that cap are possible by continuing across multiple calls. However, simply switching the model to Argon does not let you generate output approaching 1 million tokens.
There is still a limit on the number of tokens that can be generated in a single call.
The limits by call method, as shown in Google's developer documentation, are as follows.
| Call method | Output limit without continuation | Support for long generation |
|---|---|---|
| Latest Google GenAI SDK | 65,536 tokens | SDK automatically continues across multiple calls |
| REST API streaming | 65,536 tokens | Developer must implement handling that uses continuation tokens |
| REST API non-streaming | 32,768 tokens | Developer must implement handling that uses continuation tokens |
Non-streaming calls made through the SDK are also covered by the top row of the table. Note that the limit differs from calling the REST API directly.
Automatic continuation is supported in google-genai for Python from version 2.30.1 and in @google/genai for JavaScript from version 2.29.1.
In these SDKs, setting max_output_tokens to a value above 65,536 causes multiple calls to run automatically as needed.
When using the REST API directly, on the other hand, developers must implement the mechanism themselves: receive the continuation token and pass it to the next call.
Note that max_output_tokens specifies the total limit for internal reasoning and the final answer across all calls.
On hard problems, the model may use every token it can generate in an intermediate call on internal reasoning, so no answer text is returned yet. Even then, if a continuation token is returned, processing may be proceeding normally, so implementations should not treat the absence of text as a failure.
Google recommends using this kind of long-running reasoning for difficult math and science problems, complex software development and similar work.
For AI agents that repeat many short tool calls, on the other hand, Google does not recommend setting a large output limit each time.
This is because the ability to keep working over a long period is different from the ability to output a large volume of text in one pass.
Reasoning strength can be adjusted in three levels: low, medium and high. The default is medium; Google recommends it as the baseline for ordinary coding and agent work, and suggests using high for especially hard tasks.
However, a higher reasoning level increases token consumption and lengthens the time before the first response is returned.
When using it, you need to adjust the setting to the difficulty of the task, based on the reasoning level specifications.
Strong marks on long-horizon development, though rivals lead in some areas
In the benchmark results Google published, Gemini 4 Argon scored 77.9% on "DeepSWE v1.1," which measures long-running software development ability.
This beats the GPT-6 Astra and Claude models listed in the same comparison table.
On other coding-related benchmarks, however, competing models scored higher than Argon.
The evaluation results in the Google DeepMind model card are summarized below.
| Benchmark | Gemini 4 Argon | GPT-6 Astra | Claude Fable 5.1 | Claude Opus 5.5 |
|---|---|---|---|---|
| DeepSWE v1.1 | 77.9% | 74.1% | 67.4% | 74.2% |
| FrontierSWE v2 | 55.0% | 65.5% | 56.3% | 62.3% |
| Terminal-bench 4.0 | 57.4% | 58.2% | 57.9% | 66.4% |
For all of them, a higher number means a better result. However, this is a comparison as of when Google published the model card, not a ranking of every model that currently exists.
It is also worth noting that these figures were not measured under completely identical conditions.
According to the evaluation methodology Google published, Argon's DeepSWE score was measured by Google itself using mini-swe-agent. The figures for other companies' models were taken from public leaderboards and each company's model documentation.
In principle, the strongest reasoning setting was used for each model, but the amount of compute used for reasoning was not standardized.
For Terminal-bench as well, Argon's figure is Google's own measurement, while the other models' figures come from public leaderboards.
Therefore, the numbers in the table alone cannot settle which model is better in real development settings.
On the other hand, on the "Vals Index," which includes professional tasks such as finance and law, Argon scored 68.9%, ahead of the competing models Google listed for comparison.
This suggests it is highly competitive in multi-step work that requires specialized knowledge.
Still, a high score on a particular evaluation does not mean it will perform best on every coding task.
The metric that matters most differs depending on whether you are modifying existing large-scale software, solving problems by operating a terminal, or analyzing specialized materials.
According to Google, Argon is not simply a fine-tuned version of an existing model but a newly developed one.
The model card describes a large-scale MoE (Mixture of Experts) architecture, which selects and computes only the expert domains needed, and reinforcement learning to strengthen multi-step reasoning and problem-solving.
Input supports not only text but also images, audio and video. Output, on the other hand, is limited to text.
It is designed to read information in various formats and think through complex problems over long periods. However, the description of the architecture alone cannot identify the cause of the performance differences on each benchmark.
11 hours of autonomous development produced six proposals; two were adopted
As an example of how useful Gemini 4 Argon is in actual software development, Google has published the results of an experiment using its own Agent Development Kit (ADK).
According to a technical write-up on the Google Developers Blog, Argon was run autonomously for 11 hours and tasked with improving the performance of existing Python code.
The target was an open-source framework for building AI agents, with about 205,000 lines of code.
In this experiment, Argon proposed six improvements, of which only two were ultimately adopted.
One of the adopted changes streamlines how conversation history is copied.
Previously, all conversation history was copied even when only part of it was needed. This was changed so that only the necessary events are selected before copying.
The other defers the loading of heavy packages until they are needed.
Previously, even an AI agent that performed only basic text processing loaded features related to audio, video and the like at startup.
By changing this to load them only when needed, startup load was reduced.
Both are improvements aimed at cutting wasteful processing that occurs repeatedly in long sessions.
However, the changes Argon generated could not simply be adopted as-is once they passed the tests.
In fact, even a change that passed all 16,892 publicly available unit tests caused problems in 25 test targets inside Google.
In this change, the lazy-loading mechanism affected attributes referenced from the test side, so review and adjustment by human engineers were needed.
The four rejected proposals each had their own problems.
Examples include introducing a cache that could return stale data and a change that depended on private attributes inside the library.
Also passed over were a proposal that complicated conversation history handling without shortening execution time, and an added index that worked only on artificial benchmarks.
In other words, even if long autonomous exploration produces promising improvements, not all of them can be adopted in production.
Actual performance gains also vary widely depending on what is measured.
The published measurement record for the change shows the following results.
| What was measured | Before | After |
|---|---|---|
| Total processing time over 158 turns | 65.6 s | 56.1 s |
| From launching a new process to the first model request | 3.07 s | 3.09 s |
This measurement was set up so that the AI model and tools respond instantly, measuring only the processing load of ADK itself. The figures are medians from 6 to 12 runs.
Total processing time over 158 turns fell from 65.6 seconds to 56.1 seconds, a reduction of about 14.5%.
The roughly 40% improvement Google announced, on the other hand, refers to the overhead of preparation processing in long sessions. It does not mean that the AI model's reasoning time or the user's entire workflow became 40% faster.
Also, the time from launching a new process to sending the first model request has barely changed.
This is because some of the packages no longer loaded at startup have to be loaded during the first operation.
The improvement to conversation history handling also targets the approach of keeping history in memory, and the same effect is not guaranteed for approaches that load history from an external database.
What stands out in this case is that Argon searched autonomously for improvements over 11 hours, and human engineers then selected from them the changes that could actually be adopted.
The ability of AI to work for long periods is itself a strength, but verification remains essential: whether generated code breaks existing functionality, whether measurement results are reproducible, and whether the effect holds in real usage environments.
Both the adopted changes and the rejected proposals in the published case show the kind of management structure needed when entrusting AI with large-scale development work.
API pricing doubles from December; watch for added costs in long reasoning
Gemini 4 Argon's API pricing differs between the introductory period through November 30, 2026, and the period after it.
According to Google's official pricing table, standard API pricing through November 30 is $2 per 1 million input tokens and $10 per 1 million output tokens.
From December 1, these rise to $4 and $20, respectively.
| Standard API pricing tier | Through Nov. 30 | From Dec. 1 |
|---|---|---|
| 1M input tokens | $2 | $4 |
| 1M output tokens (including internal reasoning) | $10 | $20 |
| 1M cached input tokens | $0.10 | $0.20 |
This is standard API pricing; different rates apply to other processing methods such as the Batch API.
Output charges also cover not only the answer shown to the user but also the tokens the model consumed in internal reasoning.
For example, suppose that, without caching, a single call takes 200,000 input tokens and consumes 30,000 tokens in internal reasoning and the final answer combined.
During the introductory period, the cost would be:
- Input: 0.2 × $2 = $0.40
- Output: 0.03 × $10 = $0.30
- Total: $0.70
From December 1, the same job would cost $0.80 for input and $0.60 for output, for a total of $1.40.
This calculation does not include fees for search or external tools, taxes, or extra costs from retries.
Even if the text shown as the answer is short, heavy internal reasoning increases the output charge accordingly.
Furthermore, when long reasoning is split across multiple calls, you need to be careful about how input tokens are billed.
Google's technical documentation on continued generation gives an example in which an initial input of 1,000 tokens, with 200,000 tokens of reasoning and answer generated across four calls, results in a total of 397,216 billable input tokens.
This is because content generated in a previous call is carried over into the next, so the same information is repeatedly treated as input.
The cumulative input tokens billed across multiple calls do not match the scale of roughly 201,000 tokens, the initial input and generated content combined.
However, Google applies a 95% discount through implicit caching to input that is sent repeatedly in continued generation.
During the introductory period, cached input costs $0.10 per 1 million tokens.
That said, this cache has an expiration time.
According to Google, the cache expires if unused for 15 to 20 minutes, and if you resume processing after a long pause, regular pricing may apply even to repeatedly sent input.
Therefore, when estimating the cost of long reasoning, you need to consider not only the initial input and final output volume but also the number of continuations and how the cache is applied.
Also, the 95% discount is not applied unconditionally to all input.
Argon supports implicit caching, which automatically reuses common input, but it does not support caches that developers create explicitly.
When migrating an existing application to Argon, you need to check output limits and cache handling, not just change the model ID.
Google also advises reviewing these settings in its migration notes.
Autonomous AI needs safeguards as well as performance
When entrusting AI with long-running work, safety and permission management matter as much as cost and processing capacity.
In environments where AI agents read web pages, email and source code, "prompt injection" is a particular problem: malicious instructions hidden in external information can cause the agent to perform operations other than those it was meant to carry out.
Google says it strengthened Argon's resistance to such attacks during development.
According to the safety evaluation in the official announcement, in Gray Swan's indirect prompt injection evaluation, the attack success rate across 15 adaptive attempts was held to 0.7%.
However, this is a result under specific evaluation conditions and does not guarantee that attacks can be fully prevented in real operating environments.
While Google builds safeguards against misuse into the generally available version, it says it will provide the model with cybersecurity restrictions lifted only to defenders who have passed vetting in the Fairwind Program.
When introducing Argon into real work, it is important not only to rely on these model-side safeguards but also to clearly define the scope of operations the AI can perform and which tasks require human approval.
You will also need to verify on your own how much result you actually get in your real work.
For software development, for example, it would be wise to measure not only how fast code is generated but also the test pass rate, the share of changes that could actually be adopted, the time required for review and the total cost including reasoning.
The arrival of Gemini 4 Argon widens the options for having AI think through complex problems for long periods or work autonomously on improving large codebases.
However, even with a large capacity of up to 1 million tokens, that alone does not mean long-running work can be handed off with confidence.
Only when you set up continued generation, manage token consumption and cost, and properly verify the output can Argon's long-running reasoning be turned into real gains in work efficiency.