# Gemini 4 Argon

Use `gemini-4-argon` with the native Gemini format. The [model page](https://seedrouter.ai/models/gemini-4-argon) includes the Playground and current prices; the [release guide](https://seedrouter.ai/blog/gemini-4-argon-release-date) explains availability.

## Model ID

| Model ID         | Context window   | Default effort |
| ---------------- | ---------------- | -------------- |
| `gemini-4-argon` | 1,048,576 tokens | `medium`       |

## Quick example

```bash
curl https://api.seedrouter.ai/v1beta/models/gemini-4-argon:generateContent \
  -H "Authorization: Bearer $SEEDROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"contents":[{"role":"user","parts":[{"text":"Explain a mutex in one sentence."}]}],"generationConfig":{"thinkingConfig":{"thinkingLevel":"low"},"maxOutputTokens":256}}'
```

```python
import json
import os
from urllib.request import Request, urlopen

body = {
    "contents": [{"role": "user", "parts": [{"text": "Explain a mutex in one sentence."}]}],
    "generationConfig": {"thinkingConfig": {"thinkingLevel": "low"}, "maxOutputTokens": 256},
}
request = Request(
    "https://api.seedrouter.ai/v1beta/models/gemini-4-argon:generateContent",
    data=json.dumps(body).encode(),
    headers={"Authorization": f"Bearer {os.environ['SEEDROUTER_API_KEY']}", "Content-Type": "application/json"},
    method="POST",
)
with urlopen(request) as response:
    print(json.load(response))
```

```javascript
const response = await fetch(
  "https://api.seedrouter.ai/v1beta/models/gemini-4-argon:generateContent",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.SEEDROUTER_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      contents: [{ role: "user", parts: [{ text: "Explain a mutex in one sentence." }] }],
      generationConfig: { thinkingConfig: { thinkingLevel: "low" }, maxOutputTokens: 256 },
    }),
  },
);
if (!response.ok) throw new Error(await response.text());
console.log(await response.json());
```

```go
package main

import (
    "bytes"
    "fmt"
    "io"
    "net/http"
    "os"
)

func main() {
    body := []byte(`{"contents":[{"role":"user","parts":[{"text":"Explain a mutex in one sentence."}]}],"generationConfig":{"thinkingConfig":{"thinkingLevel":"low"},"maxOutputTokens":256}}`)
    req, err := http.NewRequest("POST", "https://api.seedrouter.ai/v1beta/models/gemini-4-argon:generateContent", bytes.NewReader(body))
    if err != nil { panic(err) }
    req.Header.Set("Authorization", "Bearer " + os.Getenv("SEEDROUTER_API_KEY"))
    req.Header.Set("Content-Type", "application/json")
    resp, err := http.DefaultClient.Do(req)
    if err != nil { panic(err) }
    defer resp.Body.Close()
    out, err := io.ReadAll(resp.Body)
    if err != nil { panic(err) }
    fmt.Println(string(out))
}
```

The model belongs in the URL. `contents` is required. An answer includes native `candidates`, `finishReason` and `usageMetadata`; retain complete content parts, including `thoughtSignature`, for conversation history.

## Endpoints

| Operation          | Endpoint                                                           |
| ------------------ | ------------------------------------------------------------------ |
| JSON response      | `POST /v1beta/models/gemini-4-argon:generateContent`               |
| Server-sent events | `POST /v1beta/models/gemini-4-argon:streamGenerateContent?alt=sse` |

The [OpenAPI specification](https://seedrouter.ai/docs/gemini-4-argon.openapi.json) includes every nested request and response schema. Optional fields use API defaults when omitted. Unknown and officially unsupported fields are discarded; invalid values of supported fields remain errors.

## Parameters

| Name                | Type      | Required | Default    | Notes                                                                      |
| ------------------- | --------- | -------- | ---------- | -------------------------------------------------------------------------- |
| `contents`          | object\[] | Yes      | —          | Required conversation array; `parts` carries text, media and tool results  |
| `systemInstruction` | object    | No       | —          | Text-only system instruction                                               |
| `generationConfig`  | object    | No       | —          | Output budget, thinking, structured output, stopping and media settings    |
| `tools`             | object\[] | No       | —          | Functions and built-in tool definitions                                    |
| `toolConfig`        | object    | No       | —          | Function selection, retrieval settings and server tool parts               |
| `safetySettings`    | object\[] | No       | —          | Unique category and threshold pairs                                        |
| `continuationToken` | string    | No       | —          | Opaque continuation token from the latest candidate                        |
| `serviceTier`       | enum      | No       | `standard` | `unspecified`, `standard`, `flex`, `priority`; standard by default         |
| `labels`            | object    | No       | —          | Lowercase label keys and values, up to 63 Unicode characters each          |
| `store`             | boolean   | No       | —          | Request logging preference; does not provide stored conversation retrieval |
| `model`             | string    | No       | —          | Optional body resource name; the URL fixes the model                       |

`generationConfig` includes `maxOutputTokens`, `thinkingConfig`, `stopSequences`, `responseFormat`, legacy `responseMimeType`/`responseSchema`/`responseJsonSchema`, `responseModalities`, `mediaResolution`, `seed`, `presencePenalty`, `frequencyPenalty`, `responseLogprobs`, `logprobs`, `enableEnhancedCivicAnswers`, `enableAffectiveDialog`, `translationConfig` and `audioTranscriptionConfig`. Generic fields without confirmed model-specific behavior remain subject to capability verification.

* Thinking levels: `low`, `medium`, `high`; default `medium`. Thinking cannot be disabled. `includeThoughts` requests summaries. Deprecated `thinkingBudget` is accepted alone, but cannot be combined with `thinkingLevel`.
* Input, thinking and output share 1,048,576 tokens. `maxOutputTokens` includes thinking; the remaining context may reduce the effective budget.
* Native REST uses a per-request output ceiling/default of 32,768 tokens, or 65,536 when streaming. Longer output uses continuation. Official documentation conflicts on first non-streaming requests above 32,768; this integration does not impose that as a total-generation limit.
* At most five `stopSequences`. `logprobs` ranges from 0 to 20 and requires `responseLogprobs: true`.
* `responseSchema` and `responseJsonSchema` are mutually exclusive and require `responseMimeType: "application/json"`. New requests can use `responseFormat.text` below.
* `responseModalities` can contain `TEXT` only. Temperature, top-p, top-k and candidate count are not active Argon controls. Explicit `cachedContent`, image generation and speech generation are unsupported.

## Structured output and tools

```json
{
  "contents": [{"parts": [{"text": "Return a JSON object with ok set to true."}]}],
  "generationConfig": {
    "thinkingConfig": {"thinkingLevel": "low"},
    "maxOutputTokens": 256,
    "responseFormat": {
      "text": {
        "mimeType": "APPLICATION_JSON",
        "schema": {"type": "object", "properties": {"ok": {"type": "boolean"}}, "required": ["ok"]}
      }
    }
  }
}
```

Functions use `tools[].functionDeclarations`. `allowedFunctionNames` requires mode `ANY` or `VALIDATED` and declared names. Keep function calls, responses and signatures in their original order. Google Search, Maps, code execution, URL context, File Search and Computer Use are official capabilities; resource access, charges and behavior must be verified for your intended operation. Tools are not executed locally by the Playground.

## Media and safety

Native `parts` accepts text, image, audio, video and PDF inputs through `inlineData` or `fileData`. A part contains one payload variant, optionally accompanied by thought signatures and media metadata. Global `mediaResolution` and per-part resolution are distinct. Video supports `STATIC` and `AGENTIC` processing; `videoMetadata.fps` is greater than zero and at most 24.

The Playground accepts a JSON request up to 12 MiB. This is an application transport limit, not the model’s media limit. For large media, use file references supported by your account. File resources and externally fetched media have different official limits; their availability has not yet been verified here.

Public API safety settings follow the native contract. The Playground requires medium-or-higher blocking for the four principal safety categories; lower thresholds are API only, with an administrator exception.

## Streaming and continuation

Read native JSON events from the SSE stream. Keep all parts, including tool and thinking metadata. Usage counters within one stream are cumulative: use the last usage object rather than adding every event.

When a candidate returns `continuationToken`, preserve it exactly. For `CONTINUATION`, resend the original contents, system instruction, tools and generation settings with the latest token at the **top level**. Do not append partial output to contents. For `MAX_TOKENS`, increase the output budget before resuming. The Playground prepares a continuation request for review and sends it only when you press Send again.

Each continuation is a separate request with its own usage and charge. Keep checkpoints if you implement reconnects; never assume a disconnected stream completed. The native response is retained in the Playground for inspecting all fields.

## Usage and current verification status

Input usage includes cached input; billable output includes candidate and thinking tokens. Consult the current model-page rates and your account usage records. Failed requests are not charged.

Local checks on October 14, 2026 verified text streaming, structured JSON, signed function-call round trips, code execution, Google Search and URL context, image/video/PDF understanding, thinking output and stop sequences. Audio was accepted but part of the sample was transcribed incorrectly.

`logprobs` was explicitly rejected. Requests with `maxOutputTokens: 32769` failed in both JSON and SSE checks. A valid and an invalid `continuationToken` both returned answers, so correct continuation is **not verified**. Service-tier choices and `seed` were accepted without proof of their effect. Maps, File Search, Computer Use, agentic video and external file references remain untested.

These limited checks do not establish every parameter combination or production availability. Use the native format for the complete contract; OpenAI compatibility is a separate subset and does not provide long decode.

## References

* [Official model specification](https://ai.google.dev/gemini-api/docs/models/gemini-4-argon)
* [GenerateContent migration guide](https://ai.google.dev/gemini-api/docs/generate-content/latest-model)
* [Long decode and continuation](https://ai.google.dev/gemini-api/docs/generate-content/long-decode)
* [Structured outputs](https://ai.google.dev/gemini-api/docs/generate-content/structured-output)

## Optional LLM group

Sign in to this model's [Playground](https://seedrouter.ai/models/gemini-4-argon#playground) to check the available groups. Options depend on your account permissions and the selected model. Playground uses your login session; you do not need to provide an API key.

API calls keep your API key and model ID. To select a group, send its exact name in the optional `X-SeedRouter-Group` request header. Replace `GROUP_NAME` below with a name shown in Playground. Omit the header or use `auto` to keep the key's default behavior.

```http
X-SeedRouter-Group: GROUP_NAME
```

A restricted API key may have fewer group options than Playground. Requests use the selected group's pricing and do not switch to another group if it is unavailable. This option supports HTTP LLM calls, including SSE; it does not apply to WebSocket, image or video calls.

To check the groups available to a particular API key without generating a response, use this read-only endpoint. `data[].id` is the header value; `ratio` is the account's price multiplier for that group. The `auto` entry reflects the current default estimate; its ratio is null when no default group is available. Group availability is checked again when you call the model.

```bash
curl "https://api.seedrouter.ai/api/seedrouter/llm/groups?model=gemini-4-argon" \
  -H "Authorization: Bearer YOUR_SEEDROUTER_KEY"
```