Gemini 4 Argon Denkniveau's en Lange Decodering: Standaarden, Kosten en Wanneer Elk Te Gebruiken

Gemini 4 Argon werd op 13 oktober 2026 algemeen beschikbaar en Google documenteerde de twee instellingen die bepalen wat een Argon-aanroep kost en hoe lang het duurt: het denkniveau en de uitvoerlimiet. Argon biedt drie denkniveau's: laag, gemiddeld en hoog, en standaard staat het op gemiddeld. Antwoorden stoppen bij 64K tokens, tenzij je lange decodering inschakelt, waarmee een enkel antwoord tot 1M tokens kan lopen.

Er is een addertje onder het gras bij de standaardinstellingen. Elke gepubliceerde Argon-benchmark draaide op hoog: Google evalueerde het "met de hoogste denkinstellingen", Artificial Analysis testte het op hoog, en Vals AI draaide het op hoog. Een verzoek dat geen niveau instelt, draait op gemiddeld, dus het is niet de configuratie die die scores beschrijven.

Deze post behandelt de drie niveaus en Google's advies over elk, wat hoog kost in tokens en tijd, hoe je de uitvoerlimiet instelt zodat antwoorden niet leeg terugkomen, en hoe lange decodering werkt en wordt gefactureerd. Het eindigt met code voor AIHubMix.

De korte versie

• Argon heeft drie denkniveau's: laag, gemiddeld (de standaard) en hoog. Denken kan niet worden uitgeschakeld.
• Elke gepubliceerde benchmark gebruikte hoog. Niemand heeft resultaten gepubliceerd op gemiddeld of laag.
• max_output_tokens beperkt denken en antwoorden samen. Stel het in op ten minste 32.768, of een harde prompt kan het hele budget aan denken besteden en niets teruggeven.
• Zonder lange decodering stopt een antwoord bij 65.536 tokens. Met lange decodering kan een antwoord tot 1.048.576 tokens minus je invoer lopen.
• Lange decodering factureert elke token van elke 64K "hop", en elke hop leest alles wat tot nu toe is geschreven opnieuw als invoer, met 95% korting door impliciete caching.

De drie niveaus

Google's Wat is nieuw in Gemini 4 Argon gids beschrijft de niveaus als volgt:

Google waarschuwt dat bij laag, "de kwaliteit kan dalen bij moeilijke taken", en zijn advies voor het kiezen is direct: "Voer je evaluaties uit op alle drie de niveaus, kies dan het laagste niveau dat aan je kwaliteitsnorm voldoet."

Op de native API is de instelling thinking_level, gedocumenteerd in de Gemini denk gids. Via een OpenAI-compatibele endpoint is het reasoning_effort. Google's OpenAI compatibiliteit gids koppelt de waarden voor Argon: minimaal en laag worden beide laag, gemiddeld blijft gemiddeld, hoog blijft hoog, en het weglaten geeft de standaard, gemiddeld. Er is geen niveau dat denken uitschakelt.

De standaard is gemiddeld. De benchmarks zijn hoog.

Google, Artificial Analysis en Vals rapporteren allemaal Argon op hoog. Vals stelde ook een uitvoerlimiet van 262.144 tokens in. Dus de scores die je hebt gezien beschrijven Argon op zijn hoogste niveau, en een verzoek zonder ingesteld niveau draait één stap lager.

Dat is niet per se een probleem. Gemiddeld is het niveau dat Google aanbeveelt voor het meeste werk, inclusief complexe code en agenten, en het gebruikt minder tokens dan hoog. Maar niemand heeft gepubliceerd hoeveel nauwkeurigheid gemiddeld of laag opgeeft, of hoeveel tokens ze besparen. [TBD: nauwkeurigheid en tokens per denk niveau]

Een detail is belangrijk voor vergelijkingen. GPT-6 Astra en GPT-6.1 Sol werden getest op "max", een niveau boven hoog. Een gelijke score tussen "Argon (hoog)" en "Astra (max)" is elk model op zijn plafond, niet op overeenkomende instellingen.

Wat hoog kost

Cijfers hier komen van Artificial Analysis, inclusief zijn provider snelheidstests, en van Vals AI. Allen draaiden Argon op hoog.

Denktokens worden gefactureerd als uitvoer: Google vermeldt de uitvoerprijs van Argon "inclusief denktokens", en de gebruiksgegevens rapporteren ze als total_thought_tokens. Bij ~62k uitvoertokens per taak kost een taak ongeveer $0,62 aan uitvoer alleen bij Google's introductieprijs van $10 per miljoen, en ongeveer $1,24 bij $20 per miljoen, de prijs vanaf 1 december.

Tijd volgt tokens. Bij 99,5 tot 116,5 tokens per seconde, duurt het ongeveer 9 tot 10 minuten om 62k tokens te genereren, na een wachttijd van ongeveer 45 seconden voor de eerste antwoordtoken. Interactieve producten hebben streaming en een voortgangsindicator nodig op hoog, of een lager niveau.

De uitvoerlimiet instellen

max_output_tokens is een harde limiet op denken en antwoord samen. Wanneer een antwoord deze limiet bereikt, is de status "incompleet" en komt de tekst terug afgesneden of leeg, en de denktokens worden nog steeds gefactureerd. Google's richtlijnen:

• Als je app een limiet onder 32K instelt, verhoog deze dan tot ten minste 32.768. Argon kan meer van de limiet aan denken besteden dan eerdere modellen.
• Om minder uit te geven, verlaag het denkniveau in plaats van een kleine limiet in te stellen.
• Zonder lange decodering is de standaard en maximum 65.536 tokens. Meer vragen zonder lange decodering geeft een 400-fout.
• Invoer, denken en uitvoer delen één venster van 1.048.576 tokens. Als je invoer plus max_output_tokens deze overschrijdt, krimpt de uitvoerlimiet om te passen.

Twee veranderingen ten opzichte van Gemini 3. Temperatuur, top_p en top_k worden genegeerd op Argon, dus het afstemmen ervan doet niets. En harde prompts kunnen enkele minuten duren, dus Google raadt HTTP-client time-outs van ten minste 15 minuten aan.

Lange decodering: antwoorden voorbij 64K tokens

Lange decodering is wat Google bij de lancering aankondigde als Lange Decodering Voortzetting. De lange decodering gids beschrijft twee manieren om het uit te voeren.

Achtergronduitvoering (Interacties API). Maak de interactie met background=True en max_output_tokens boven 65.536. Achtergronduitvoering heeft store=true nodig. De server schrijft het antwoord in hops van maximaal 64K tokens, waarbij elke hop doorgaat waar de laatste stopte, tot 24 uur. Elke hop voegt een model_output stap toe, dus voeg ze samen wanneer de interactie is voltooid. Stel background=True in zonder max_output_tokens te verhogen en het stopt bij 64K.

Klantzijde voortzetting (generateContent API). Elke hop retourneert tot 64K tokens bij streaming of via de SDK, 32K voor een niet-streaming REST-aanroep. Een hop die zijn limiet bereikt eindigt met finish_reason: CONTINUATION en een continuation_token, en het volgende verzoek stuurt dezelfde invoer plus de token. Recente SDK's doen dit voor je: Python google-genai 2.30.1 en JavaScript @google/genai 2.29.1 of later. Elk verzoek heeft een limiet van 20 minuten.

Bij het streamen van een lange decodering, sla de interactie-ID en de laatste event_id op, maak opnieuw verbinding met last_event_id wanneer de stream wegvalt, en stel leesperiodes in van 15 tot 20 minuten. Na de eerste 64K tokens arriveert de stream in stukken van ongeveer 5.000 tokens met pauzes ertussen.

Google is duidelijk over wanneer het de moeite waard is:

Een hogere limiet geeft het model ruimte om te denken; het maakt normale antwoorden niet langer. Het model beslist hoeveel het schrijft, en het volgt geen woord- of token-doelen.

Hoe lange decodering wordt gefactureerd

Je betaalt voor elke token in elke hop, inclusief hops die alleen denken bevatten. Elke hop stuurt ook je prompt plus alles wat tot nu toe is gegenereerd terug naar het model als invoer, dus die tokens tellen opnieuw mee. Google's voorbeeld: een prompt van 1.000 tokens die 200.000 tokens aan denken en uitvoer produceert, vereist vier hops.

De gebruiksgegevens rapporteren ongeveer 397.000 invoertokens, hoewel de context slechts ongeveer 201.000 bevat. Impliciete caching kort de herhaalde invoer met 95% af, dus het is goedkoop: tegen de introductieprijzen kosten de 200.000 uitvoertokens $2,00, en ongeveer 396.000 herhaalde invoertokens tegen $0,10 per miljoen voegen ongeveer $0,04 toe. Uitvoer domineert nog steeds de rekening.

Twee neveneffecten. Gebruik total_input_tokens niet om te beslissen wanneer je een gesprek moet inkorten of samenvatten, aangezien het de context overschat; voeg in plaats daarvan je promptgrootte toe aan de uitvoer- en denktotalen. En geannuleerde of mislukte interacties factureren al het werk dat vóór hun stop is gedaan.

Waar te beginnen, per werkbelasting

Deze volgen Google's niveau richtlijnen; er zijn geen gepubliceerde nauwkeurigheden per niveau om ze te verfijnen.

Test vervolgens één niveau lager. Als het goedkopere niveau aan je eisen voldoet op je eigen evaluatieset, houd het dan.

Houd het niveau vast binnen een sessie. Argon cachet impliciet, waardoor herhaalde invoer met 95% wordt afgeprijsd voor prompts van ten minste 4.096 tokens, en de AIHubMix Gemini gids merkt op dat een cache-hit dezelfde inhoud, model en parameters nodig heeft. Het wisselen van niveaus tussen beurten kan gecachte invoer terugbrengen naar volledige prijsinvoer.

Het niveau en de limiet instellen op AIHubMix

Argon is op AIHubMix als gemini-4-argon, op de OpenAI-compatibele endpoint en via de native Google GenAI SDK. Voor de meeste verzoeken, stel het niveau en de limiet expliciet in:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://aihubmix.com/v1",
    api_key=os.environ["AIHUBMIX_API_KEY"],
    timeout=900,  # harde prompts kunnen enkele minuten duren
)

resp = client.chat.completions.create(
    model="gemini-4-argon",
    reasoning_effort="medium",  # Argon's standaard; de benchmarks gebruikten "hoog"
    max_tokens=32768,           # beperkt denken en antwoord samen
    messages=[
        {"role": "user", "content": "Beoordeel deze betalingsdienst op racecondities in de retry-logica.\n\n<source code>"},
    ],
)
print(resp.choices[0].message.content)
print(resp.usage)

Voor lange decodering, gebruik de native SDK gericht op de Gemini endpoint van AIHubMix. De gids van AIHubMix documenteert de Interacties API daar, inclusief achtergrondmodus, met google-genai 2.0.0 of later. Het patroon hieronder is Google's gedocumenteerde patroon; het is nog niet getest via AIHubMix. [TBD: lange decodering via AIHubMix]

import os
import time
from google import genai

client = genai.Client(
    api_key=os.environ["AIHUBMIX_API_KEY"],
    http_options={"base_url": "https://aihubmix.com/gemini"},
)

interaction = client.interactions.create(
    model="gemini-4-argon",
    input="Schrijf de volledige test suite voor deze betalingsmodule, met een test voor elke randgeval.\n\n<source code>",
    background=True,
    generation_config={"max_output_tokens": 262144, "thinking_level": "hoog"},
)
while interaction.status in ("in_progress", "queued"):
    time.sleep(5)
    interaction = client.interactions.get(id=interaction.id)

# Elke hop voegt een model_output stap toe; voeg ze allemaal samen.
text = "".join(
    part.text
    for step in interaction.steps
    if step.type == "model_output"
    for part in step.content
    if part.type == "text"
)
print(interaction.status, interaction.usage)

Argon's AIHubMix model pagina vermeldt de ondersteunde invoer, mogelijkheden en huidige prijs.

FAQ

Welke denkniveau's ondersteunt Gemini 4 Argon?
Laag, gemiddeld en hoog. De standaard is gemiddeld, en denken kan niet worden uitgeschakeld.

Op welk niveau werden de benchmarks van Argon uitgevoerd?
Hoog. Google, Artificial Analysis en Vals AI rapporteren allemaal Argon op hoog, en niemand heeft resultaten gepubliceerd op gemiddeld of laag.

Hoe stel ik het niveau in via de OpenAI SDK?
Gebruik reasoning_effort. Voor Argon worden minimaal en laag beide laag, gemiddeld blijft gemiddeld en hoog blijft hoog. Laat het weg om gemiddeld te krijgen.

Waarom gaf Argon een leeg antwoord terug?
Het heeft waarschijnlijk het hele budget van max_output_tokens aan denken besteed. Het antwoord komt incompleet terug en de denktokens worden nog steeds gefactureerd. Verhoog de limiet tot ten minste 32.768 of verlaag het denkniveau.

Hoe krijg ik meer dan 64K uitvoertokens?
Gebruik lange decodering. Stel op de Interacties API background in op true en max_output_tokens boven 65.536. Gebruik op generateContent een recente SDK, die automatisch doorgaat over hops.

Hoe wordt lange decodering gefactureerd?
Je betaalt voor elke token in elke hop. Elke hop stuurt de prompt en alles wat tot nu toe is gegenereerd terug als invoer, en impliciete caching kort die herhaalde invoer met 95% af. Geannuleerde of mislukte runs factureren het werk dat al is gedaan.

Werkt temperatuur nog steeds op Gemini 4 Argon?
Nee. Temperatuur, top_p en top_k worden genegeerd, dus verwijder ze en gebruik het denkniveau om het gedrag te controleren.

Blijf lezen: de Gemini 4 Argon serie

• Controleer voordat je instellingen afstemt of Argon überhaupt het juiste model voor je werkbelasting is: Gemini 4 Argon: Frontier Scores, een 1M-Token Uitvoerlimiet, en Hoe Het Nu Te Roepen
• Hoog denken is wat Argon's taken duur maakt. Gemeten kosten per taak, van twee onafhankelijke testers: Gemini 4 Argon Prijzen: Goedkoop Per Token, Niet Per Taak
• De denkstandaard, de uitvoerlimiet en genegeerde samplingparameters zijn drie van de wijzigingen op de migratiechecklist: Overstappen naar Gemini 4 Argon van Gemini 3.1 Pro of 3.8 Flash: Wat Breekt en Hoe Het Te Fixen

Bronnen

• Wat is nieuw in Gemini 4 Argon (Google AI voor Ontwikkelaars)
• Gemini denken (Google AI voor Ontwikkelaars)
• Lange decodering (Google AI voor Ontwikkelaars)
• Gemini 4 Argon: Google is terug als een van de top drie laboratoria in behaalde intelligentie (Artificial Analysis)
• Gemini 4 Argon op AIHubMix (AIHubMix)