
Gemini 4 Carbon API og Gemini 4 Argon API tar samme forespørsel og koster det samme per input- og output-token, så valget mellom dem er en rutingbeslutning, ikke en migrering. På PoYo bytter du ved å endre én streng: gemini-4-carbon (modellside) eller gemini-4-argon (modellside). Dette innlegget går gjennom hva som skiller dem på API-nivå, hva Googles benchmarkforskjeller sier om hvilke forespørsler som hører hjemme på Carbon, og en ruter du kan legge rett inn i koden din.
Ny med Carbon? Begynn med Gemini 4 Carbon API-oversikten og guiden til første forespørsel. For Argon alene, se Gemini 4 Argon API-guiden.
Gemini 4 Carbon API vs Gemini 4 Argon API i korte trekk
| Gemini 4 Carbon | Gemini 4 Argon | |
|---|---|---|
| PoYo-modell-ID | gemini-4-carbon | gemini-4-argon |
| Endepunkter på PoYo | POST /v1/chat/completions, POST /v1beta/models/gemini-4-carbon:generateContent / :streamGenerateContent | Samme to formater, med gemini-4-argon |
| Kontekstvindu | 1M tokens | 1M tokens |
| Maks. output per svar | 64K tokens | Større: Google beskriver en felles input-output-grense på 1M (se vår Argon-guide) |
| Inputtyper | Tekst, bilde, lyd, video, PDF | Tekst, bilde, lyd, video, PDF |
| Googles posisjonering | Sterkeste resonneringsmodell; bruker flere tokens på å utforske, resonnere og verifisere | Effektiv modell: raskere svar, lavere tokenforbruk per runde |
| Googles anbefaling | Den vanskeligste kodingen i mange trinn, feilsøking, åpen research | "Det ideelle valget for det meste av programvareutvikling og kunnskapsarbeid" |
Forespørselsstrukturen er identisk. I Chat Completions står modell-ID-en i feltet model; i Gemini Native står den i URL-stien. Begge modellene støtter strømming ("stream": true eller :streamGenerateContent). Feilene er også de samme: 400 for ugyldige felt eller feil format, 401 for en ugyldig nøkkel, 404 for en ukjent modell-ID og 402 når kredittene dine er brukt opp.
Den eneste grensen som tvinger frem en bestemt rute, er outputstørrelsen. Carbons dokumenterte tak er 64K output-tokens per svar. Hvis ett enkelt svar må være lengre enn det (for eksempel en full omskriving av flere filer i én omgang), send det til Argon.
Migreringsdiff: hva som endres i JSON-en
Slik flytter du en forespørsel fra Argon til Carbon i Chat Completions:
{
- "model": "gemini-4-argon",
+ "model": "gemini-4-carbon",
"messages": [
{"role": "user", "content": "Find the root cause of the failing test and propose a patch."}
],
- "max_tokens": 120000,
+ "max_tokens": 64000,
"stream": true
}
I Gemini Native endres bare stien:
POST https://api.poyo.ai/v1beta/models/gemini-4-argon:generateContent
POST https://api.poyo.ai/v1beta/models/gemini-4-carbon:generateContent
Begrens max_tokens (Chat Completions) eller generationConfig.maxOutputTokens (Gemini Native) til 64 000 eller mindre når du kaller Carbon. Ingenting annet i brødteksten trenger å endres.
Pris per token: lik, bortsett fra cache-lesing
PoYo-priser fra de gjeldende modellsidene (1 kreditt = $0.005):
| Måler (per 1M tokens) | Gemini 4 Carbon på PoYo | Gemini 4 Argon på PoYo | Google offisiell (begge, introduksjon) |
|---|---|---|---|
| Input | $1.60 (320 kreditter) | $1.60 (320 kreditter) | $2.00 |
| Output (inkl. thinking) | $8.00 (1,600 kreditter) | $8.00 (1,600 kreditter) | $10.00 |
| Cache-lesing | $0.08 (16 kreditter) | $0.16 (32 kreditter) | $0.10 (95 % rabatt på input) |
Google lanserte Carbon til Argons introduksjonspris. Innlegget om tilgjengelighet sier at introduksjonsperioden slutter 30. november 2026, og at $4 for input og $20 for output per 1M tokens gjelder fra 1. desember. Innlegget om Carbon-priser sammenligner begge Google-satsene med gjeldende PoYo-pris.
Forskjellen ligger i linjen for cache-lesing: på PoYo koster Carbons cache-lesinger halvparten av Argons. Besparelsen er reell, men liten. Den er $0.08 per 1M cachede tokens, og 10 000 ekstra output-tokens ($0.08 ved $8.00 per 1M) spiser den opp. Siden Google sier at Carbon bruker flere tokens per oppgave enn Argon, bør du regne med at Carbon koster mer per oppgave på de fleste arbeidslaster, selv med den billigere cachen.
Et regneeksempel med identiske tokenantall (400K cache-lesinger, 50K nytt input, 20K output):
| Carbon | Argon | |
|---|---|---|
| Utregning | 0.4 × $0.08 + 0.05 × $1.60 + 0.02 × $8.00 | 0.4 × $0.16 + 0.05 × $1.60 + 0.02 × $8.00 |
| Kostnad | $0.272 (54.4 kreditter) | $0.304 (60.8 kreditter) |
Hvis Carbon trenger 30K output-tokens for samme oppgave i stedet for 20K, koster den $0.352. Derfor bør du måle kostnad per fullført oppgave, ikke kostnad per token. Måleskriptet står nedenfor.
Benchmarkforskjeller som grunnlag for ruting
Dette er Googles egne tall fra lanseringstabellen for Gemini 4 Carbon, så se på dem som leverandørens sammenligning, ikke en uavhengig test. Kolonnen med forskjellen viser hvor de ekstra tokenene lønner seg.
| Benchmark | Carbon | Argon | Forskjell |
|---|---|---|---|
| ExploitGym | 54.8% | 42.0% | +12.8 |
| GraphWalks 256K–1M (BFS F1) | 96.2% | 84.2% | +12.0 |
| AA Intelligence Index v5.0 | 59 | 50 | +9 |
| Agents' Last Exam v1.1 | 77.4% | 69.0% | +8.4 |
| Terminal-Bench 4.0 (AA) | 65.2% | 57.1% | +8.1 |
| OSWorld-2.1 (offline-delmengde) | 81.5% | 74.7% | +6.8 |
| FrontierSWE 2 | 61.2% | 55.0% | +6.2 |
| SWE-sweep | 9.6% | 4.3% | +5.3 |
| SEC-bench Pro | 88.2% | 83.4% | +4.8 |
| RiemannBench | 80.0% | 76.0% | +4.0 |
| CWE-bench | 71.0% | 68.0% | +3.0 |
| AutomationBench (Zapier) | 53.9% | 51.3% | +2.6 |
| Vals Index v2.2 | 70.4% | 69.2% | +1.2 |
Les den som en rutingtabell:
- Store forskjeller: send til Carbon. Gjenfinning i lang kontekst på tvers av 256K–1M tokens, terminalstyrt agentarbeid, agentoppgaver i mange trinn og validering av exploits.
- Små forskjeller: behold på Argon. Forretningsautomatisering (+2,6), generelt kunnskapsarbeid (Vals Index, +1,2) og generering av rettelser på CWE-bench (+3,0). Her får Argon det meste av scoren og bruker færre tokens per runde.
- Forbehold om cyber. Googles resultater innen cybersikkerhet gjenspeiler tilgang via Fairwind Program, og innlegget om tilgjengelighet sier at Carbon for cyber bare tilbys via det programmet. Ikke anta at det offentlige API-et gjenskaper disse resultatene. Test på dine egne oppgaver.
Sammenlign bare resultater innenfor én tabell. Vår Argon-guide siterer Googles lanseringstabell for Argon, som oppgir Terminal-Bench 4.0 til 57,4 % for Argon. Carbon-tabellen bruker testoppsettet til Artificial Analysis (57,1 %).
Rutingstrategi: Argon som standard, eskaler til Carbon
Googles anbefaling og benchmarkforskjellene peker mot samme design:
- Send alle forespørsler til
gemini-4-argonsom standard. - Send kjent vanskelige oppgavetyper rett til
gemini-4-carbon: feilsøking på tvers av hele repositoriet, terminalagenter, spørsmål over mer enn 256K tokens kontekst og sikkerhetstriage. - Eskaler ved feil. Hvis Argons svar ikke består sjekken din (tester, skjemavalidering, en bedømmer) eller stopper med
finish_reason: "length", prøv én gang til på Carbon. - Tving Argon når svaret må være lengre enn 64K tokens.
Denne ruteren bruker OpenAI SDK-et pekt mot PoYos Chat Completions-endepunkt. Den sender bare dokumenterte felt: model, messages og max_tokens.
import os
from openai import OpenAI
client = OpenAI(api_key=os.environ["POYO_API_KEY"], base_url="https://api.poyo.ai/v1")
ARGON, CARBON = "gemini-4-argon", "gemini-4-carbon"
CARBON_MAX_OUTPUT = 64_000
# PoYo USD per 1M tokens, from the model pages on 2026-11-16
PRICE = {ARGON: (1.60, 8.00), CARBON: (1.60, 8.00)}
# Task types where Google's table shows the widest Carbon lead
CARBON_TASKS = {"repo_debug", "terminal_agent", "long_context_qa", "security_triage"}
def pick_model(task_type: str, max_tokens: int) -> str:
if max_tokens > CARBON_MAX_OUTPUT:
return ARGON
return CARBON if task_type in CARBON_TASKS else ARGON
def call(model: str, messages: list, max_tokens: int) -> dict:
resp = client.chat.completions.create(model=model, messages=messages, max_tokens=max_tokens)
u = resp.usage
price_in, price_out = PRICE[model]
cost = u.prompt_tokens / 1e6 * price_in + u.completion_tokens / 1e6 * price_out
return {
"model": resp.model,
"text": resp.choices[0].message.content,
"finish_reason": resp.choices[0].finish_reason,
"prompt_tokens": u.prompt_tokens,
"completion_tokens": u.completion_tokens,
"cost_usd": round(cost, 6),
}
def run(task_type: str, messages: list, check, max_tokens: int = 16_000) -> list:
"""Returns every attempt so you can log cost per task, including escalations."""
first = pick_model(task_type, max_tokens)
attempts = [call(first, messages, max_tokens)]
a = attempts[-1]
failed = a["finish_reason"] == "length" or not check(a["text"])
if first == ARGON and failed and max_tokens <= CARBON_MAX_OUTPUT:
attempts.append(call(CARBON, messages, max_tokens))
return attempts
check er din egen akseptansetest, for eksempel "rettelsen lar seg anvende og testene består" eller "JSON-en kan parses mot skjemaet mitt". Kostnadsestimatet behandler hver prompt-token som ikke-cachet input. PoYos dokumenterte usage-felt skiller ikke ut cachede tokens, så dette er en øvre grense.
Mål kostnad per oppgave selv
Prisene per token er like, så det eneste tallet som skiller de to API-ene, er kostnad per godkjent oppgave. Logg hvert forsøk fra run():
| Felt som skal logges | Kilde i Chat Completions | Kilde i Gemini Native |
|---|---|---|
| Modell som faktisk ble brukt | model | URL-sti |
| Input-tokens | usage.prompt_tokens | usageMetadata.promptTokenCount |
| Output-tokens | usage.completion_tokens | usageMetadata.candidatesTokenCount + thoughtsTokenCount |
| Traff outputtaket | finish_reason == "length" | finishReason |
| Besto sjekken din | bedømmeren din | bedømmeren din |
Google priser output inkludert thinking-tokens, så i Gemini Native skal thoughtsTokenCount telles som output. Med strømming inneholder den siste Chat Completions-chunken usage. Deretter, per oppgavetype:
cost per accepted task = sum(cost_usd of all attempts, incl. escalations) / tasks that passed
Kjør en uke med ekte trafikk med Argon som standard, og sammenlign med et utvalg som sendes rett til Carbon. Hvis Carbon består oppgaver som Argon trengte en eskalering for, legg den oppgavetypen til i CARBON_TASKS. Hvis Carbons beståttrate for en type er lik Argons, behold den typen på Argon. Sammenhold PoYo-dashbordet ditt med loggen din for de første par hundre kallene.
Hvis du også vurderer modeller fra andre leverandører, se Gemini 4 Carbon API vs Claude Opus 5.5 API vs GPT-6 Astra API. For en agentløkke med budsjettvern, se Gemini 4 Carbon API for kodeagenter.
Ofte stilte spørsmål
Er Gemini 4 Carbon API dyrere enn Gemini 4 Argon API?
Ikke per token. Begge koster $1.60 for input og $8.00 for output per 1M tokens på PoYo, og $2.00 / $10.00 med Googles introduksjonspriser. På PoYo er Carbons cache-lesing billigere ($0.08 mot $0.16 per 1M). Per oppgave koster Carbon som regel mer, fordi Google sier at den bruker flere tokens på å resonnere og verifisere.
Hvordan bytter jeg fra Gemini 4 Argon API til Gemini 4 Carbon API?
Endre "model": "gemini-4-argon" til "model": "gemini-4-carbon" i Chat Completions, eller endre modellen i URL-stien i Gemini Native. Hold max_tokens på 64 000 eller lavere for Carbon.
Hva er maks. output for Gemini 4 Carbon API sammenlignet med Argon?
Carbon returnerer opptil 64K output-tokens per svar, med et kontekstvindu på 1M tokens. Argon tillater mye lengre enkeltsvar, så send output over 64K til Argon.
Bør jeg bruke Gemini 4 Argon eller Gemini 4 Carbon til koding?
Google sier at Argon fortsatt er det ideelle valget for det meste av programvareutvikling. Bruk Carbon til den vanskeligste feilsøkingen i mange trinn og terminalstyrt agentarbeid, der Googles tabell viser de største forskjellene: Terminal-Bench 4.0 (AA) 65,2 % mot 57,1 % og SWE-sweep 9,6 % mot 4,3 %.
Bruker Gemini 4 Carbon og Argon samme API-endepunkt?
Ja. Begge fungerer med POST https://api.poyo.ai/v1/chat/completions (OpenAI-kompatibel) og POST https://api.poyo.ai/v1beta/models/{model}:generateContent eller :streamGenerateContent (Gemini Native), med samme PoYo API-nøkkel.