Introduction
Gemini 4 Argon API brings Google’s reasoning model to software investigations and multi-step knowledge work, with text, images and audio in one chat. Its 1,048,576-token context is shared by input, thinking and output. On Argon’s synchronous endpoint, max_tokens defaults to 4,096 and stops at 65,536, including thinking; the separate long-decode mode is unavailable here, so leave space for the answer within the shared context.
| Field | Value |
|---|---|
| Input | Text |
| Output | Text |
| Shared context | 1,048,576 tokens for Argon input, thinking and output together |
| max_tokens ceiling | 65,536 |
| Inputs | text / images / audio |
Key features & highlights
Argon’s shared window for investigation
Gemini 4 Argon API brings Google’s reasoning model to software investigations and multi-step knowledge work, with text, images and audio in one chat. Its 1,048,576-token context is shared by input, thinking and output. For an Argon investigation, ask which passage supports each finding and which check would resolve the uncertainty before accepting a proposed code change.
Pictures and recordings next to the question
A user message can mix text with image_url parts and audio, sent as an audio_url or as base64 input_audio in wav or mp3 form. Charts, screenshots, scanned pages and voice notes sit in the same conversation as your instructions, which suits investigation tasks where the evidence is not all text.
Three levels of thinking, one field
reasoning_effort takes low, medium or high and defaults to medium. Use low for quick lookups and rewrites, medium for everyday analysis, and high when a wrong answer costs more than the extra tokens. Thinking is paid for out of max_tokens, so raise the cap with the level.
Tools that keep your application in charge
Gemini 4 Argon can answer with a function call instead of prose. Your code validates the arguments, runs the operation and returns the result as a tool message, so the model proposes a step and your application decides whether to take it.
Request parameters
| Parameter | Required | Description |
|---|---|---|
messages | Yes | Send Argon the source passages, screenshots and conversation in messages, retaining |
max_tokens | No | On Argon’s synchronous endpoint, |
reasoning_effort | No | Argon offers |
stop | No | Argon accepts one stop marker or up to four markers, and ends the answer before the first matched marker rather than returning that marker as content. at least 1 characters · at least 1 items · at most 4 items |
temperature | No | Argon’s temperature spans 0–2; keep the default for an initial evidence review and change sampling only when you need a different response style. |
top_p | No | Argon’s |
tools | No | Define up to 128 functions for Argon to request during a code or document investigation; your application checks the proposed arguments, runs the operation and returns the resul… at most 128 items |
parallel_tool_calls | No |
|
tool_choice | No | For Argon’s next step, |
response_format | No | Use |
Pricing
Input $4 / Output $20 per 1 million tokens
Use cases
Cross-check a pile of documents
Send the contract, the amendment and the email thread in one request and ask which obligations changed, quoting the passage each answer rests on. Give every source a short label and say which version wins when two disagree.
Review a repository against a spec
Put the specification and the relevant source files into one conversation and ask for mismatches you can point to a line for. With the callers in view the review can follow a function across files; set reasoning_effort to high for the hard ones.
Make sense of charts, screenshots and calls
Attach a dashboard screenshot and a recorded stand-up and ask what changed and what is still undecided. Say which image or clip each question concerns so the model does not have to guess.
Drive an agent loop with your own tools
Define up to 128 functions, let the model request calls, run them yourself and feed the results back. Keep the loop short, validate every argument, and stop on a step limit your code controls.
Prompt guide & pro tips
Arrange Argon’s sources before the final question
Place long documents early in the conversation and ask your question after them. Keep persona, tone and output format in the system message so they hold however long the history grows.
Pick a level, then leave room for thinking
Start at medium.
max_tokensdefaults to 4,096 and includes thinking, so for a long report or a high-effort run set it well above the length you expect to read, up to 65,536.Label what you attach
Name each document and say which image or audio clip a question is about. Keep instructions apart from quoted source text so a sentence inside a document is not mistaken for your request.
Ask for a contract you can check
For machine-readable output pass a
response_formator define a tool whose parameters are the fields you want, then validate what comes back before acting on it.
Gemini 4 Argon API brings Google’s reasoning model to software investigations and multi-step knowledge work, with text, images and audio in one chat. Its 1,048,576-token context is shared by input, thinking and output.
google/gemini-4-argon/chat — /v1/chat/completions
On Argon’s synchronous endpoint, max_tokens defaults to 4,096 and stops at 65,536, including thinking; the separate long-decode mode is unavailable here, so leave space for the answer within the shared context.
Argon offers reasoning_effort low, medium and high, starting at medium; increase the output allowance when deeper reasoning needs more tokens, and note that thinking cannot be switched off here.
Send Argon the source passages, screenshots and conversation in messages, retaining tool_call_id for returned function results; audio must be inline and fit the combined 14 MB media limit.
For an Argon investigation, ask which passage supports each finding and which check would resolve the uncertainty before accepting a proposed code change.
Define up to 128 functions for Argon to request during a code or document investigation; your application checks the proposed arguments, runs the operation and returns the result with its tool_call_id.
Use response_format for an Argon evidence table encoded as JSON, then check the fields and types in your application before consuming the result.
Argon’s content decisions still apply to this chat, including NSFW requests; SpicyAPI does not promise unrestricted answers from Google’s reasoning model.
API quick start
curl --fail-with-body -sN https://api.spicyapi.ai/v1/chat/completions \
-H "Authorization: Bearer $SPICY_API_KEY" \
-H "Content-Type: application/json" \
-H "Idempotency-Key: $(uuidgen)" \
-d '{
"model": "google/gemini-4-argon/chat",
"messages": [
{
"role": "user",
"content": "Summarise the following release notes into three bullet points."
}
],
"stream": true
}' \
| jq --unbuffered -Rrj 'select(startswith("data: ")) | .[6:] | select(. != "[DONE]") | fromjson | if .error then "\n[error] \(.error.message)\n" else (.choices[0].delta.content? // empty) end'
See the API reference for authentication, the complete schema, polling, and error handling.
