
Gemini 4 Carbon API er Googles valg til det sværeste kodearbejde. Google byggede den til fejlfinding i mange trin og agentisk kodning over lange forløb og siger, at den bruger flere tokens end Argon på at udforske, ræsonnere og køre verifikationsløkker. Denne guide kobler gemini-4-carbon (modelside) ind i en kodeagent via PoYo's OpenAI-kompatible endpoint. Agenten streamer sit output, kan læse en stor del af repositoriet, stopper ved et fast loft over runder og dollars og ved, hvornår arbejdet skal gives videre til Argon.
Hvis du endnu ikke har sendt en første anmodning, så start med Gemini 4 Carbon API-guiden.
Hvad API'et giver en kodeagent
| Punkt | Gemini 4 Carbon på PoYo |
|---|---|
| Model-ID | gemini-4-carbon |
| Agent-endpoint brugt her | POST https://api.poyo.ai/v1/chat/completions (OpenAI SDK, base_url="https://api.poyo.ai/v1") |
| Native alternativ | POST /v1beta/models/gemini-4-carbon:generateContent og :streamGenerateContent |
| Kontekstvindue | 1M tokens: tekst, billede, lyd, video, PDF |
| Maks. output pr. svar | 64K tokens |
| Streaming | "stream": true; den sidste chunk indeholder finish_reason og usage |
| Pris | $1.60 input / $8.00 output / $0.08 cache-læsning pr. 1M tokens (320 / 1,600 / 16 kreditter) |
| Rate limits | PoYo's dokumentation oplyser, at LLM-endpoints i øjeblikket ikke er rate limited |
| Fejl | 400 ugyldige felter, 401 ugyldig nøgle, 402 utilstrækkelige kreditter, 404 ukendt model; prøv 429 / 500 / 502 / 503 igen med backoff |
Chat Completions-dokumentationen dokumenterer disse anmodningsfelter: model, messages (streng-content med rollerne system, user eller assistant), max_tokens, stream, temperature, top_p, stop, n og penalty-felterne. Agenten nedenfor bruger kun dem.
Tool calling: hvad der er dokumenteret i dag
PoYo dokumenterer tools for Anthropic Messages og for Responses. Det dokumenterer ikke tools eller funktionsdeklarationer for Gemini-modeller, hverken i Chat Completions eller Gemini Native. Responses er ikke tilgængelig for gemini-4-carbon.
Derfor sender denne agent ikke et tools-array. Den bruger i stedet en JSON-handlingsprotokol i almindeligt beskedindhold. Systemprompten oplister de tilladte handlinger, modellen svarer med ét JSON-objekt pr. runde, og din kode udfører handlingen og sender resultatet tilbage som næste brugerbesked. Det virker med enhver chatmodel. Når PoYo dokumenterer native function calling for Gemini, kan du udskifte parseren med rigtige tool calls og beholde resten af løkken.
Der er også en sikkerhedsfordel: modellen kan kun anmode om fire handlinger, som du selv har skrevet. Den kan ikke køre en vilkårlig shell-kommando.
Repo-input med lang kontekst: 1M ind, 64K ud
Et vindue på 1M tokens lader dig sende en stor del af repositoriet i første runde i stedet for at hente filer én ad gangen. Googles lanceringstabel giver en grund til at bruge det: Carbon scorer 96,2% på GraphWalks ved 256K–1M tokens mod 84,2% for Argon. Tre grænser former løkken:
- Hver runde gensender hele historikken. Snapshottet afregnes igen ved hvert kald. Et snapshot på 300K tokens over 12 runder er mindst 3,6M input-tokens, hvilket er $5.76 ved $1.60 pr. 1M før noget output.
- Output er begrænset til 64K pr. svar. Bed om én fil pr.
write_file-handling, ikke en omskrivning af hele repositoriet i ét svar. - Mål tokenantallet i stedet for at gætte. PoYo dokumenterer intet tokenizer-endpoint. Læs
usage.prompt_tokensfra det første kald, og justér derefterMAX_SNAPSHOT_CHARStil det tokenbudget, du ønsker.
Caching. PoYo's pristabel har en cache-læsningstakst for Carbon ($0.08 pr. 1M mod $1.60 for nyt input), og Google prissætter cachet input med 95% rabat. PoYo's dokumentation beskriver ingen anmodningsparameter til caching eller noget usage-felt for cachede tokens for Gemini-modeller. Denne løkke sender ingen cachingparameter og budgetterer hver prompt-token til den fulde inputtakst. Det koster intet at holde systemprompten og snapshottet som et uændret præfiks, og din regning vil vise, om nogen læsninger blev afregnet til cachetaksten.
Den afgrænsede agentløkke i Python
import json
import os
import subprocess
import time
from pathlib import Path
from openai import OpenAI, APIStatusError
client = OpenAI(api_key=os.environ["POYO_API_KEY"], base_url="https://api.poyo.ai/v1")
CARBON, ARGON = "gemini-4-carbon", "gemini-4-argon"
PRICE_IN, PRICE_OUT = 1.60, 8.00 # PoYo USD per 1M tokens, same for both (2026-11-16)
MAX_TURNS = 12
BUDGET_USD = 2.00
MAX_TOKENS_PER_TURN = 16_000 # Carbon allows up to 64,000
MAX_SNAPSHOT_CHARS = 400_000 # tune against usage.prompt_tokens
MAX_RESULT_CHARS = 20_000
REPO = Path("./my-repo").resolve()
SYSTEM = """You are a coding agent working in a Python repository.
Reply with exactly one JSON object and nothing else. Allowed actions:
{"action": "read_file", "path": "<relative path>"}
{"action": "write_file", "path": "<relative path>", "content": "<full file content>"}
{"action": "run_tests"}
{"action": "done", "summary": "<what changed and why>"}"""
def snapshot() -> str:
parts, total = [], 0
for p in sorted(REPO.rglob("*.py")):
block = f"### {p.relative_to(REPO)}\n{p.read_text(encoding='utf-8', errors='replace')}\n"
if total + len(block) > MAX_SNAPSHOT_CHARS:
break
parts.append(block)
total += len(block)
return "".join(parts)
def safe_path(rel: str) -> Path:
p = (REPO / rel).resolve()
if not p.is_relative_to(REPO):
raise ValueError("path outside repository")
return p
def execute(action: dict) -> str:
kind = action.get("action")
if kind == "read_file":
return safe_path(action["path"]).read_text(encoding="utf-8", errors="replace")
if kind == "write_file":
safe_path(action["path"]).write_text(action["content"], encoding="utf-8")
return "written"
if kind == "run_tests":
r = subprocess.run(["pytest", "-q"], cwd=REPO, capture_output=True, text=True, timeout=600)
return f"exit={r.returncode}\n{r.stdout}\n{r.stderr}"
raise ValueError(f"unknown action {kind!r}")
def call(model: str, messages: list):
"""One streamed turn. Returns (text, usage, finish_reason)."""
for attempt in range(4):
try:
stream = client.chat.completions.create(
model=model, messages=messages, max_tokens=MAX_TOKENS_PER_TURN, stream=True
)
text, usage, finish = [], None, None
for chunk in stream:
if chunk.choices:
choice = chunk.choices[0]
if choice.delta and choice.delta.content:
text.append(choice.delta.content)
print(choice.delta.content, end="", flush=True)
finish = choice.finish_reason or finish
if getattr(chunk, "usage", None):
usage = chunk.usage
return "".join(text), usage, finish
except APIStatusError as e:
if e.status_code in (429, 500, 502, 503) and attempt < 3:
time.sleep(2 ** attempt)
continue
raise # 400, 401, 402, 404: fix the request or the account, don't retry
def parse(text: str) -> dict:
t = text.strip()
if t.startswith("```"):
t = t.strip("`").removeprefix("json").strip()
return json.loads(t)
def run_agent(task: str, model: str = CARBON) -> dict:
messages = [
{"role": "system", "content": SYSTEM},
{"role": "user", "content": f"Repository snapshot:\n{snapshot()}\n\nTask: {task}"},
]
spent, last_prompt = 0.0, 0
for turn in range(1, MAX_TURNS + 1):
# Worst case for the next turn: at least last turn's input plus a full output
worst_next = last_prompt / 1e6 * PRICE_IN + MAX_TOKENS_PER_TURN / 1e6 * PRICE_OUT
if spent + worst_next > BUDGET_USD:
return {"status": "budget_stop", "turns": turn - 1, "spent_usd": round(spent, 4)}
text, usage, finish = call(model, messages)
if usage is None:
raise RuntimeError("no usage in stream; stopping so the budget stays enforceable")
spent += usage.prompt_tokens / 1e6 * PRICE_IN + usage.completion_tokens / 1e6 * PRICE_OUT
last_prompt = usage.prompt_tokens
messages.append({"role": "assistant", "content": text})
if finish == "length":
messages.append({"role": "user", "content": "Reply was cut off. Send one shorter JSON action."})
continue
try:
action = parse(text)
except json.JSONDecodeError:
messages.append({"role": "user", "content": "Reply with exactly one JSON object."})
continue
if action.get("action") == "done":
return {"status": "done", "summary": action.get("summary"), "turns": turn, "spent_usd": round(spent, 4)}
try:
result = execute(action)
except Exception as e: # report the failure to the model instead of crashing
result = f"error: {e}"
messages.append({"role": "user", "content": f"Result of {action.get('action')}:\n{result[:MAX_RESULT_CHARS]}"})
return {"status": "max_turns", "turns": MAX_TURNS, "spent_usd": round(spent, 4)}
if __name__ == "__main__":
print(run_agent("tests/test_parser.py::test_unicode fails. Find the root cause and fix it."))
Path.is_relative_to kræver Python 3.9 eller nyere. Kør agenten mod en kopi eller en branch af repositoriet, da write_file overskriver filer.
Sådan virker omkostningsværnene
| Værn | Hvad det stopper | Hvor tallet kommer fra |
|---|---|---|
MAX_TURNS | Løkker, der aldrig kalder done | Dit valg; 12 er et udgangspunkt |
BUDGET_USD + worst case-tjek | Forbrug ud over loftet ved næste kald | usage.prompt_tokens og usage.completion_tokens fra den sidste stream-chunk, til PoYo's $1.60 / $8.00 |
MAX_TOKENS_PER_TURN | Ét løbsk svar | max_tokens, højst 64,000 for Carbon |
MAX_RESULT_CHARS | Store testlogs, der puster alle senere runder op | Afkortning, før resultatet kommer ind i historikken |
usage is None → stop | Skjult forbrug, du ikke kan måle | PoYo dokumenterer usage på den sidste stream-chunk |
402 prøves ikke igen | Lavine af genforsøg på en tom saldo | PoYo-fejlkoder |
Google prissætter Carbons output inklusive thinking-tokens, så en runde kan afregne mere output end den synlige JSON. Derfor bruger budgettet completion_tokens og tæller aldrig de tegn, du modtog. Estimatet regner alt input som ikke-cachet, så det er en øvre grænse for, hvad PoYo vil afregne. Sammenhold det med dit dashboard for de første par kørsler.
Worst case-tjekket er konservativt. Med en historik på 300K tokens koster én runde mere mindst $0.48 i input plus op til $0.128 i output ved max_tokens på 16K. Med et budget på $2.00 stopper løkken før det kald, der kunne overskride loftet.
Hvornår du skal falde tilbage til Gemini 4 Argon
Argon tager den samme anmodning og koster det samme pr. input- og output-token. Google kalder den "det ideelle valg til størstedelen af softwareudvikling og vidensarbejde", med hurtigere svar og lavere tokenforbrug pr. runde. Send til den med run_agent(task, model=ARGON), når:
- Opgaven er rutine. Små rettelser, ændringer i én fil og skrivning af tests har ikke brug for Carbons ekstra verifikationstokens.
- Ét svar skal være længere end 64K tokens. Carbon begrænser output til 64K. Vores Argon-guide beskriver Argons meget større outputgrænse.
- Du vil have et billigt første forsøg. Kør Argon først, og eskaler kun til Carbon, når testene stadig fejler. Routeren i Gemini 4 Carbon API vs Gemini 4 Argon API gør netop det.
Behold Carbon til rodårsagsanalyse på tværs af hele repositoriet og terminaltunge løkker. I Googles tabel scorer Carbon 65,2% på Terminal-Bench 4.0 (AA) mod Argons 57,1% og 9,6% på SWE-sweep mod 4,3%. Googles indlæg om tilgængelighed foreslår også en opdeling: Carbon til roller inden for arkitektur, koordinering og revision, kombineret med hurtigere, lettere modeller til parallelt arbejde. I denne løkke betyder det én Carbon-planlægningskørsel, der fordeler filer til Argon-workers.
Budgetter for begge modeller findes i indlægget om Gemini 4 Carbon API-priser. Hvis du overvejer andre leverandører til agenten, se Gemini 4 Carbon API vs Claude Opus 5.5 API vs GPT-6 Astra API.
Ofte stillede spørgsmål
Understøtter Gemini 4 Carbon API function calling på PoYo?
PoYo's nuværende dokumentation beskriver ikke tools eller funktionsdeklarationer for Gemini-modeller i Chat Completions eller Gemini Native. Tools er dokumenteret for Anthropic Messages og Responses. Denne guide bruger en JSON-handlingsprotokol i beskedindholdet, som kun kræver dokumenterede felter.
Kan jeg bruge OpenAI Python SDK med Gemini 4 Carbon API?
Ja. Opret OpenAI(api_key=..., base_url="https://api.poyo.ai/v1"), og angiv model="gemini-4-carbon" til chat.completions.create. Streaming virker med stream=True, og den sidste chunk indeholder usage.
Hvad er det maksimale output og kontekstvinduet for Gemini 4 Carbon API?
1M tokens kontekst og op til 64K output-tokens pr. svar. Sæt max_tokens til 64.000 eller mindre.
Hvordan begrænser jeg omkostningerne ved Gemini 4 Carbon API i en agentløkke?
Begræns antallet af runder, begræns max_tokens pr. runde, afkort værktøjsresultater, og stop, når forbruget indtil nu plus en worst case-runde ville overskride dit budget. Beregn forbruget ud fra usage.prompt_tokens × $1.60 og usage.completion_tokens × $8.00 pr. 1M tokens på PoYo.
Understøtter Gemini 4 Carbon API kontekstcaching?
PoYo angiver en cache-læsningspris for Carbon på $0.08 pr. 1M tokens (16 kreditter). Dokumentationen beskriver i øjeblikket ingen anmodningsparameter til caching eller noget usage-felt for cachede tokens for Gemini-modeller, så budgetter prompts til den fulde inputtakst, og tjek din regning for afregninger til cachetaksten.
Hvornår skal en kodeagent bruge Gemini 4 Argon i stedet for Carbon?
Brug Argon til rutinekodning, til ethvert enkeltsvar, der skal være længere end 64K tokens, og som et billigere første forsøg, før du eskalerer til Carbon. Begge koster $1.60 / $8.00 pr. 1M tokens på PoYo, men Google siger, at Argon bruger færre tokens pr. runde.