Google AI for Developers lists gemini-4-argon with Thinking enabled by default (medium) and supports three levels: low, medium, and high. Its input, thinking, and output share a 1,048,576-token context, while ordinary synchronous requests have a max_output_tokens limit of 65,536; exceeding that value requires background=True Long Decode.
Tasks this suits: Complex Gemini 4 Argon tasks that need an explicit thinking level or need to work within its 1M shared context and Long Decode boundaries.
Tasks this does not suit: Tasks requiring more than the shared 1,048,576-token context, or tasks that generate more than 65,536 tokens with background=False; the page explicitly says the latter returns a 400 error.
Applicable model version: gemini-4-argon.
Applicable client, agent, or API: Gemini API Thinking configuration; the model table and the Argon limitations section on the page apply to this model. The code examples on the page use gemini-3.8-flash and do not provide a complete Argon-specific request.
Recommended thinking level and parameters: Argon defaults to medium Thinking and supports low, medium, and high. The page does not prescribe a fixed level for any Argon task; max_output_tokens counts thinking and output together and is constrained by the shared context and synchronous/Long Decode boundaries.
| Configuration | Explicit value on the page |
|---|---|
| Model | gemini-4-argon |
| Default Thinking | On (medium) |
| Supported Thinking levels | low, medium, high |
What max_output_tokens counts | The combined total of thinking tokens and output tokens |
| Shared context | Input, thinking, and output share 1,048,576 tokens |
| Default synchronous output limit | 65,536 tokens; applies to streaming and non-streaming requests with background=False |
| Above the synchronous limit | With max_output_tokens > 65536 and background=False, the API returns a 400 error |
| Long Decode | Set background=True and max_output_tokens above 65,536; the maximum can reach 1,048,576 tokens minus input tokens |
Use thinking_level to select low, medium, or high; the page lists medium as Argon’s default level.
Treat max_output_tokens as a shared hard limit for thinking and visible output, rather than a limit on final text alone.
Calculate available output space as 1,048,576 - input tokens. If input tokens plus max_output_tokens exceeds 1,048,576, the API automatically limits the output ceiling to the remaining context space.
For ordinary synchronous calls with background=False, both the default and maximum max_output_tokens values are 65,536; use background=True Long Decode when more is required.
If max_output_tokens is exhausted during thinking, the status is incomplete and the output may be truncated or empty; already generated thinking tokens are still billed.
The page does not show complete Python, JavaScript, Java, Go, or REST request code for gemini-4-argon; its code examples use gemini-3.8-flash. This note therefore does not rewrite or label those examples as Argon-specific code.
Fix the model as gemini-4-argon and record the default Thinking level shown on the page: medium.
Run the same task separately with low, medium, and high, recording the actual thinking level, thinking tokens, output tokens, total tokens, status, and latency. The page confirms only the supported levels, not quality or cost comparisons among them.
Check whether input tokens plus max_output_tokens exceeds 1,048,576; if it does, record how the API automatically compresses the output ceiling to the remaining context.
Verify the 65,536 limit in streaming and non-streaming calls with background=False; use a value above 65,536 as a failure case and confirm the 400 error.
For Argon tasks requiring longer thinking or output, set background=True and max_output_tokens above 65,536; separately record the actual Long Decode ceiling as 1,048,576 minus input tokens.
Set a lower max_output_tokens value and let the task continue thinking; verify the incomplete status, truncated or empty output at the hard limit, and the fact that thinking tokens are still billed.
Do not treat the page’s gemini-3.8-flash examples for generic code, Thought summaries, streaming events, or best practices as Argon-specific configuration. For Argon code, use Argon model documentation and actual API validation.
The model table directly lists gemini-4-argon with On (medium) as Default Thinking and low, medium, high as Levels Supported.
In the Gemini 4 model limitations section, which explicitly includes gemini-4-argon, the page states that input, thinking, and output share a 1,048,576-token 1M context window.
The page states that with background=False (for both streaming and non-streaming requests), the default and maximum max_output_tokens limit is 65,536 tokens; a value above 65,536 returns a 400 error.
The page states that to let Gemini 4, including gemini-4-argon, generate more than 65,536 and up to 1,048,576 tokens, set background=True and configure max_output_tokens above 65,536.
The page defines max_output_tokens as the maximum tokens that can be generated in the response, including thinking tokens; this is an infrastructure-enforced hard cutoff and does not change how the model allocates its Thinking budget.
The page explains that if the model reaches this limit while thinking, the status is incomplete and the output may be truncated or empty; thinking tokens already generated are still billed.
The page recommends lowering thinking_level (low or medium) to reduce cost or latency without truncating the response, rather than setting max_output_tokens very low.
The page’s code for demonstrating Thinking, Thought summaries, streaming events, and thinking_level calls uses gemini-3.8-flash as the model name; this note does not rewrite those generic examples as Argon code.
The page provides the Gemini 4 model guide, Long Decode documentation, and Token counting guide as follow-up links.
medium is the default Thinking level shown by the page for gemini-4-argon; it does not mean every task should use that level.
max_output_tokens consumes both thinking and output capacity; it cannot be used to represent visible-text length alone.
1,048,576 is the shared context limit for input, thinking, and output; available output must be reduced by input tokens, and the API automatically limits output to the remaining space when the total exceeds the limit.
65,536 is the synchronous default and maximum output limit with background=False; the higher Long Decode limit requires background=True and cannot be forced through an ordinary synchronous request.
The Argon-specific content listed on the page is the model table and the Gemini 4 limitations section. Other code, Thought summaries, signatures, streaming events, and best-practice sections do not use Argon as the example and should not be treated as verified Argon-specific behavior.
The page does not provide an Argon-specific complete request schema, SDK version, authentication method, or price or quality differences among Thinking levels; these details cannot be filled in from this page.
Use an actual Gemini API request with model="gemini-4-argon", and record visible configuration and actual usage for thinking_level values low, medium, and high.
Fix the input and separately test background=False with max_output_tokens=65536 and max_output_tokens>65536, confirming that the latter returns a 400 error.
Use background=True for tasks above 65,536, increment max_output_tokens gradually, and check the available output ceiling against 1,048,576 - input tokens.
Construct a thinking task that exhausts max_output_tokens, and record incomplete, truncated or empty output, and the billing result for total_thought_tokens.
Compare Argon’s actual results against the model row and limitations explicitly listed on the page; do not use the page’s gemini-3.8-flash examples to infer Argon’s undisclosed schema or behavior.
Gemini 4 Argon
