TL;DR
Gebruik de Gemini 4 Carbon API in CometAPI om redeneren en documentanalyse aan je applicatie toe te voegen via de Gemini-native GenerateContent-interface. Begin met een kort tekstverzoek, controleer of de generatie is voltooid en sla het antwoord op voordat je PDF-input, afbeeldingen, streaming of gestructureerde JSON toevoegt. Deze gids bevat de setup en de code voor het afhandelen van responses in elke stap.
Key Takeaways
- Model-ID:
gemini-4-carbon. Geen gratis tier — vereist betaalde Gemini API / Cloud Billing. - Geünificeerd venster van 1M tokens (input + thinking + output). Standaard max output ~65K; long decode rekt uit tot bijna 1M.
- Denkniveaus:
low(snel/voordelig),medium(standaard, gebalanceerd),high(diep redeneren). - Introductieprijs tot 30 november 2026: $2 / $10 per 1M tokens (cached input $0,10). Verdubbelt op 1 december.
- Uitstekend voor langetermijn agentische coding, wetenschappelijke redenering, kenniswerk en cybersecurity-taken.
- Officiële SDK’s (google-genai) + OpenAI-compatibele endpoints beschikbaar.
- CometAPI biedt de eenvoudigste productie-toegang met één sleutel, scherpe tarieven en naadloos schakelen tussen Gemini 4 Carbon, Claude en 500+ andere modellen.
Lancering-illustratie Gemini 4 Carbon. Afbeelding: Google. Originele illustratie.
What Is Gemini 4 Carbon API?
Gemini 4 Carbon is Google’s frontier-reasoningmodel voor langetermijn agentische workflows, complexe software-engineering, cybersecurity en wetenschappelijk onderzoek. Gebouwd op Gemini 4 Argon gebruikt het diepere redenering en uitgebreide verificatielussen om meerstapstaken aan te pakken die volgehouden probleemoplossing vergen in plaats van één enkel antwoord. In vergelijking met Argon is Carbon ontworpen voor veeleisendere workloads waarbij nauwkeurigheid en taakvoltooiing zwaarder wegen dan het minimaliseren van tokengebruik. Google kondigde betaalde ontwikkelaarstoegang op 10 november 2026 aan. De multimodale inputondersteuning laat je tekst combineren met visuele en andere media-input; de gegenereerde output is tekst. CometAPI biedt korting op API-toegang.
Voor een API-integratie begin je met één taak waarvan je het resultaat kunt controleren: vat een document samen, extraheer velden uit een incidentnotitie of beoordeel een screenshot. Een bredere agent-workflow kan voortbouwen op dat werkende verzoek zodra je de ondersteunde tools en het responsegedrag van de route hebt geverifieerd.
Other Ways to Use It
- Google AI Studio Playground: Selecteer het model en test prompts interactief (betaalde toegang vereist voor Carbon).
- Gemini app / AI Mode / Antigravity: Beschikbaar als je Google AI Ultra hebt (selecteer het model waar aangeboden).
- Enterprise / Cloud: Gebruik via Gemini Enterprise Agent Platform of Vertex-achtige endpoints met dezelfde model-ID (project + locatieconfiguratie).
- Wetenschappers/onderzoekers kunnen in sommige gevallen beperkte gratis toegang aanvragen.
What Are the Gemini 4 Carbon API Specifications ?
De officiële modelspecificaties onderscheiden het gedeelde contextbudget van de outputlimiet per foregroundsegment. Dit zijn modelniveaulimieten; jouw gateway kan ook beperkingen op aanvraaggrootte en features toepassen.
Limitations and API Considerations
Controleer voordat je je integratie uitbreidt hoe Carbon omgaat met context, generatiesettings, caching en toegang. De tabel koppelt elke beperking aan een praktische actie, zodat je ongeldige verzoeken, onvolledige resultaten en onverwachte kosten vermijdt.
Google’s Carbon-ontwikkelaarsgids documenteert de API-regels; de modelkaart beschrijft betrouwbaarheid en beperkingen voor gespecialiseerde toegang. Bevestig de corresponderende features op je CometAPI-route voordat je ze in productie inschakelt.
Thinking Levels: How to Choose the Right Setting
Begin met MEDIUM en pas het niveau vervolgens aan de taak en de gewenste kwaliteit aan.
- LOW: Gebruik dit voor eenvoudige extractie, classificatie en samenvattingen wanneer responstijd en kosten prioriteit hebben. Probeer het voor taken zoals het labelen van supporttickets en controleer of het nog steeds je nauwkeurigheidsdoel haalt.
- MEDIUM: Gebruik dit standaard startpunt voor dagelijks coderen, documentanalyse en routinematig redeneren. Het is een praktische baseline om te evalueren of een ander niveau je applicatie verbetert.
- HIGH: Gebruik dit voor complex debuggen, meerstaps onderzoek en wetenschappelijke redenering die baat heeft bij diepere verkenning. Houd rekening met extra denktokens en behoud dit alleen wanneer de kwaliteitswinst de extra kosten en tijd rechtvaardigt.
Hogere denkniveaus garanderen niet automatisch betere resultaten voor elke taak. Benchmark je eigen workloads en vergelijk taakvoltooiingskwaliteit, latentie en totaal tokengebruik voordat je productiestandaarden wijzigt.
How Does Gemini 4 Carbon Perform on AI Benchmarks?
Selected Benchmark Results
De pagina’s Artificial Analysis Carbon (High) en Argon (High) tonen de volgende momentopname, gecontroleerd op 12 november 2026. Dit zijn benchmarkresultaten, geen metingen van de CometAPI-latentie.
De outputtokentotalen beslaan de hele evaluatie, niet één verzoek. Taakkosten gebruiken de prijsaanname van Artificial Analysis in plaats van de huidige korting van CometAPI. Carbon wacht langer op de eerste antwoordtoken, maar voltooit de benchmarktaak sneller en tegen lagere gerapporteerde kosten; alleen het tokenvolume bepaalt de waarde niet.
Gebruik Carbon wanneer de diepere verificatie moeilijke code-review, onderzoek of ander werk waarbij fouten kostbaar zijn, verbetert. Test Argon voor routinematig coderen en kennistaken, maar bevestig besparingen op je eigen workload. Voer identieke prompts uit en vergelijk de totale uitgaven gedeeld door geaccepteerde resultaten, naast voltooiingstijd en faalpercentage.
How Do You start with the Gemini 4 Carbon API in CometAPI?
Je hebt een CometAPI-account nodig met toegang tot het model en voldoende tegoed, een Python-omgeving en basiskennis van het uitvoeren van scripts. Gebruik een projectmap voor onderstaande bestanden, zodat elk voorbeeld dezelfde clientconfiguratie kan importeren.
Why Use Gemini 4 Carbon API Through CometAPI?
CometAPI is handig als je Carbon naast andere modellen wilt evalueren, terwijl je toegang en facturatie via één provider beheert. De Carbon-route biedt zowel de Gemini-native GenerateContent als een OpenAI-compatibele Chat-interface, zodat je het aanvraagformaat kunt kiezen dat bij je applicatie past.
Voor deze gids laat de native route je de Google Gen AI SDK hergebruiken met een CometAPI-sleutel en base-URL. De huidige prijzen voor de standaardgroep liggen 20% onder Google’s introductietarieven. Houd je model-ID in de configuratie zodat je Carbon en Argon kunt vergelijken zonder je applicatie te herschrijven, en controleer routespecifieke ondersteuning voordat je tools, bestandsuploads of lange vervolgoutputs toevoegt.
Step 1: Create Your Account and Set Your API Key
Meld je aan bij CometAPI, maak of open je API-sleutel en sla deze op als omgevingsvariabele. Vermijd het direct opnemen van sleutels in broncode of het committen ervan in een repository.
Gebruik de opdracht voor je shell. Stel de variabelen in dezelfde terminal in die je gebruikt om Python uit te voeren; vervang de sleutelplaceholder door je eigen sleutel.
Stel sleutel en model in PowerShell in.
$env:COMETAPI_KEY = "YOUR_COMETAPI_KEY"
$env:COMETAPI_MODEL = "gemini-4-carbon"
Stel sleutel en model in Bash in.
export COMETAPI_KEY="YOUR_COMETAPI_KEY"
export COMETAPI_MODEL="gemini-4-carbon"
Step 2: Install the SDK and Configure the Endpoint
Installeer de SDK in je projectomgeving. Met python -m pip blijft de installer gekoppeld aan de interpreter die het voorbeeld zal uitvoeren.
Installeer of werk de Google Gen AI SDK bij.
python -m pip install --upgrade google-genai
CometAPI documenteert een Gemini-native endpoint met een aangepaste SDK-base-URL. Gebruik je CometAPI-sleutel voor dit endpoint. De onderstaande instellingen gelden voor GenerateContent-verzoeken.
Step 3: Create a Reusable Client and Validate Responses
Sla dit op als carbon_client.py. Het definieert de client één keer en biedt completed_text voor de tekst-only responses die in deze gids worden gebruikt. De helper controleert de candidate finish reason voordat het antwoordtekst retourneert, zodat een lege of afgekorte uitkomst niet stilzwijgend als succes wordt behandeld.
Maak carbon_client.py met de CometAPI-client en een validator voor tekstresponses.
import os
from google import genai
from google.genai import types
client = genai.Client(
api_key=os.environ["COMETAPI_KEY"],
http_options={
"api_version": "v1beta",
"base_url": "https://api.cometapi.com",
},
)
model = os.getenv("COMETAPI_MODEL", "gemini-4-carbon")
def completed_text(response):
if not response.candidates:
raise RuntimeError("No candidate returned; inspect prompt feedback.")
candidate = response.candidates[0]
reason = getattr(candidate.finish_reason, "value", candidate.finish_reason)
if reason != "STOP":
raise RuntimeError(f"Generation did not finish normally: {reason}")
parts = candidate.content.parts if candidate.content else []
text = "".join(
part.text or "" for part in (parts or []) if not part.thought
)
if not text.strip():
raise RuntimeError("The completed candidate contains no answer text.")
return text
Step 4: Send Your First Request and Check the Result
Maak first_request.py naast carbon_client.py en voeg onderstaande code toe. Deze stuurt een korte checklistprompt met MEDIUM-thinking en een outputbudget van 4.096 tokens, controleert voltooiing met completed_text(response) en slaat het antwoord op in answer.txt als UTF-8. Voer in je projectmap python first_request.py uit, open daarna answer.txt en bevestig dat alle vijf de beoordelingspunten relevant en bruikbaar zijn. Controleer de afgedrukte gebruiksmetadata op tokenverbruik, inclusief thinking; een normale afsluiting bevestigt niet de antwoordkwaliteit. Als het verzoek faalt of onvolledige output retourneert, gebruik dan de probleemoplossingssectie om referenties, foutdetails en de afsluitreden te controleren voordat je het nogmaals probeert.
from pathlib import Path
from carbon_client import client, model, types, completed_text
response = client.models.generate_content(
model=model,
contents="Give me a five-point checklist for reviewing a Python API client.",
config=types.GenerateContentConfig(
max_output_tokens=4096,
thinking_config=types.ThinkingConfig(thinking_level="MEDIUM"),
),
)
answer = completed_text(response)
Path("answer.txt").write_text(answer, encoding="utf-8")
print(answer)
print("Saved answer.txt")
if response.usage_metadata:
print(response.usage_metadata.model_dump(exclude_none=True))
python first_request.py
## How Can Gemini 4 Carbon API Analyze Files?
Voer deze voorbeelden uit vanuit dezelfde map als carbon_client.py. Ze laden lokale bestanden in inline content parts, waardoor de initiële workflow onafhankelijk blijft van een aparte bestandsuploadservice.
PDF-begrip omvat visuele content: Gemini kan tekst, tabellen, grafieken en afbeeldingen samen interpreteren. Google’s [documentverwerkingsgids](https://ai.google.dev/gemini-api/docs/document-processing) beschrijft ondersteuning voor PDF’s tot 1.000 pagina’s, onderhevig aan bestandsgrootte- en contextlimieten. Het paginalimiet is een bovengrens, geen garantie dat elk document in een gatewayverzoek past.
Gebruik inline input voor kleine, tijdelijke PDF’s. Voor grotere bestanden of herhaalde meer-draai vragen raadt Google de Files API aan om te voorkomen dat je het volledige bestand steeds opnieuw verzendt. Controleer vóórdat je die workflow via CometAPI gebruikt het uploadendpoint en de ondersteuning voor bestandsreferenties; het inline voorbeeld hieronder blijft een praktische start.
### Summarize a local PDF
Google documenteert [inline PDF-input](https://ai.google.dev/gemini-api/docs/document-processing) voor GenerateContent. Plaats een klein, niet-gevoelig bestand report.pdf in de projectmap, sla het volgende op als analyze_pdf.py en voer python analyze_pdf.py uit.
Stuur een lokaal PDF-bestand en sla de voltooide samenvatting op.
from pathlib import Path
from carbon_client import client, model, types, completed_text
response = client.models.generate_content(
model=model,
contents=[
types.Part.from_bytes(
data=Path("report.pdf").read_bytes(),
mime_type="application/pdf",
),
"Summarize this report in five bullets. Do not invent missing figures.",
],
config=types.GenerateContentConfig(max_output_tokens=4096),
)
summary = completed_text(response)
Path("report_summary.txt").write_text(summary, encoding="utf-8")
print(summary)
Controleer de samenvatting met het bestand voordat je uitbreidt naar grotere documenten. Limieten voor aanvraaggrootte en bestandsreferenties zijn afhankelijk van de gateway. Google’s ondersteuning voor Office-formaten of Cloud Storage-referenties bevestigt op zichzelf niet de ondersteuning voor die inputs via jouw CometAPI-route.
### Review a local screenshot
Voor [inline afbeelding-input](https://ai.google.dev/gemini-api/docs/image-understanding) moet het MIME-type overeenkomen met het bestand. Plaats een PNG-schermafbeelding met de naam screen.png naast het script. Sla dit voorbeeld op als analyze_image.py en voer python analyze_image.py uit om zichtbare tekst en lay-out te beoordelen.
Analyseer een PNG-schermafbeelding zonder te vertrouwen op een publieke afbeeldings-URL.
from pathlib import Path
from carbon_client import client, model, types, completed_text
response = client.models.generate_content(
model=model,
contents=[
types.Part.from_bytes(
data=Path("screen.png").read_bytes(),
mime_type="image/png",
),
"Review this screenshot for unreadable text and overlapping elements. "
"Describe only visible issues and identify their locations.",
],
config=types.GenerateContentConfig(max_output_tokens=4096),
)
print(completed_text(response))
Vergelijk elk gerapporteerd probleem met de schermafbeelding. Als je in plaats daarvan een JPEG verzendt, wijzig zowel de bestandsnaam als het MIME-type overeenkomstig; alleen de extensie wijzigen converteert de afbeelding niet.
## How Do You Stream Gemini 4 Carbon Responses ?
### Display streamed text and check completion
Streaming retourneert response-chunks als server-sent events (SSE), waardoor een applicatie gedeeltelijke output kan tonen terwijl de generatie doorgaat.
De SDK biedt [streaming tekstgeneratie](https://ai.google.dev/gemini-api/docs/text-generation) via generate_content_stream. Voor directe HTTP-verzoeken gebruikt CometAPI streamGenerateContent met alt=sse.
Sla het volgende op als stream_response.py en voer python stream_response.py uit. Het toont tekst zodra die arriveert en verifieert vervolgens dat de stream eindigde met een normale afsluitreden. Een uitzondering laat de getoonde tekst achter als een gedeeltelijk resultaat, niet als een geaccepteerd antwoord.
Lees gestreamde tekst en vereist een normale beëindiging voordat je deze accepteert.
from carbon_client import client, model, types
finish_reason = None
received_text = False
for chunk in client.models.generate_content_stream(
model=model,
contents="Write a concise checklist for investigating intermittent API timeouts.",
config=types.GenerateContentConfig(max_output_tokens=4096),
):
if not chunk.candidates:
continue
candidate = chunk.candidates[0]
if candidate.finish_reason is not None:
finish_reason = getattr(candidate.finish_reason, "value", candidate.finish_reason)
parts = candidate.content.parts if candidate.content else []
for part in parts or []:
if part.text and not part.thought:
received_text = True
print(part.text, end="", flush=True)
print()
if finish_reason != "STOP" or not received_text:
raise RuntimeError(f"Stream not accepted as complete: {finish_reason}")
### Extract structured JSON
Voor [schema-gebonden output](https://ai.google.dev/gemini-api/docs/structured-output) vraag je application/json aan en definieer je de velden die je applicatie verwacht. Dit voorbeeld extraheert twee velden uit een korte incidentnotitie en controleert vervolgens hun types voordat het resultaat wordt afgedrukt.
Sla dit voorbeeld op als structured_output.py en voer python structured_output.py uit. Het hergebruikt de responsevalidator vóór het parsen van de JSON.
Extraheer incidentvelden, controleer voltooiing en valideer hun types.
import json
from carbon_client import client, model, types, completed_text
response = client.models.generate_content(
model=model,
contents=(
"Extract the service and impact from this incident note: "
"The checkout API returned errors for ten minutes during a database restart."
),
config=types.GenerateContentConfig(
max_output_tokens=4096,
response_mime_type="application/json",
response_schema={
"type": "OBJECT",
"properties": {
"service": {"type": "STRING"},
"impact": {"type": "STRING"},
},
"required": ["service", "impact"],
},
),
)
data = json.loads(completed_text(response))
if not isinstance(data, dict) or not all(
isinstance(data.get(field), str) for field in ("service", "impact")
):
raise ValueError("The response does not match the expected field types.")
print(json.dumps(data, indent=2))
Je zou een object met service en impact moeten ontvangen. Naleving van het schema bewijst geen feitelijke juistheid: vergelijk geëxtraheerde waarden met de input en pas eventuele bedrijfsregels toe voordat je het resultaat opslaat of erop handelt.
## Gemini 4 Carbon API Price
Google’s [introductieprijzen](https://blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-4-carbon-now-available/) lopen tot en met 30 november 2026; de standaardtarieven gelden vanaf 1 december. Controleer de huidige tarieven van je account voordat je latere verzoeken begroot.
Beide modellen behoren tot de Gemini 4-familie, maar richten zich op verschillende workloads.
| API pricing tier | Input / 1M tokens | Output / 1M tokens |
| ------------------------- | ----------------- | ------------------ |
| Standard (through Nov 30) | $2.00 | $10.00 |
| Standard (from Dec 1) | $4.00 | $20.00 |
| Batch (through Nov 30) | $1.00 | $5.00 |
| Batch (from Dec 1) | $2.00 | $10.00 |
| Flex (through Nov 30) | $1.00 | $5.00 |
| Priority (through Nov 30) | $3.60 | $18.00 |
Aanvullende prijsdetails:
* Cached input: $0,10 per miljoen tokens tot en met 30 november, stijgt naar $0,20 vanaf 1 december.
* Batch en Flex bieden goedkopere verwerking voor workloads die hun servicekenmerken kunnen tolereren.
* Denktokens worden als outputtokens gefactureerd.
* Tokens die worden verbruikt door interne toolinstructies en functiedeclaraties kunnen ook factureerbaar zijn.
Google raadt expliciet Argon aan voor de meeste software-engineering en kenniswerk, en reserveert Carbon voor taken die diepere redenering en uitgebreide verificatie vereisen.
Praktische aanbeveling: Kies Carbon wanneer de kosten van een onjuist resultaat hoog zijn of wanneer een taak substantiële verkenning en verificatie vereist. Kies Argon wanneer je sterke redenering nodig hebt met een efficiënter tokenbudget.
### CometAPI Price
Zoals gecontroleerd op 12 november 2026 vermeldt [CometAPI’s standaardgroepschema](https://www.cometapi.com/models/google/gemini-4-carbon/) $1,60 per miljoen inputtokens, $8,00 per miljoen outputtokens inclusief thinking, en $0,08 per miljoen cached-inputtokens bij cache-hits. Deze tarieven liggen 20% onder Google’s overeenkomstige introductietarieven.
De prijzen van CometAPI kunnen veranderen naarmate Google’s officiële tarieven wijzigen. Vergelijk het huidige officiële tarief met de korting die aan je account is gekoppeld in plaats van de dollarprijs van vandaag als vast te beschouwen. Als dezelfde 20% korting behouden blijft na een tariefwijziging, is jouw tarief het nieuwe officiële tarief × 0,80; bevestig het daadwerkelijke CometAPI-tarief voordat je gaat begroten. Andere accountgroepen kunnen andere kortingen hebben.
Voor een verzoek met 100.000 niet-gecachte inputtokens en 10.000 outputtokens, inclusief thinking, zijn de tokenkosten $0,24 tegen het weergegeven CometAPI-tarief: $0,16 voor input plus $0,08 voor output. Dezelfde hoeveelheden kosten $0,30 bij Google’s introductietarieven of $0,60 bij de decembertarieven. De gecombineerde 110.000 tokens passen binnen het gedeelde budget van het model.
Deze schatting sluit tools, retries en eventuele accountspecifieke prijsaanpassingen uit. Outputkosten omvatten denktokens, dus een hoger denkniveau kan de rekening verhogen, zelfs als het zichtbare antwoord kort is.
### How to Optimize Gemini 4 Carbon API Costs?
Optimaliseer voor de kosten van een correct, bruikbaar resultaat. Een goedkoper verzoek is slechte waarde als je het moet herhalen of het antwoord handmatig moet herstellen.
1. Kies redenering bewust. Begin op MEDIUM, test LOW voor eenvoudig werk en gebruik HIGH wanneer dit de acceptatie voldoende verbetert om de extra tijd en tokens te rechtvaardigen.
2. Hergebruik stabiele context via impliciete caching. De workflows van Google’s [Argon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-argon) en [Carbon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-carbon) ondersteunen geen expliciete context-cachecreatie; ze ondersteunen impliciete caching. Plaats herbruikbare instructies en documenten eerst, gevolgd door de veranderende vraag. Google documenteert geschiktheid voor gedeelde prefixes van minimaal 4.096 tokens. Verifieer daadwerkelijke cache-hits en kosten op je CometAPI-route; herhaling garandeert geen korting.
3. Verminder onnodig werk. Stuur relevante pagina’s of fragmenten, vraag de outputvelden aan die je nodig hebt en stel een voldoende outputbudget in. Thinking telt mee voor outputgebruik, dus een te lage cap kan afkapping en retries veroorzaken.
4. Meet de volledige workflow. Neem redenering, toolgebruik, retries en afgewezen antwoorden mee in de totale uitgaven. Sla geldige responses op zodat downstream opslagfouten geen nieuwe generatie triggeren.
5. Route op bewezen waarde. Vergelijk Carbon en Argon op identieke taken. Overweeg Batch of Flex alleen wanneer je provider ze ondersteunt en de workload hun verwerkingseigenschappen kan tolereren.
Volg de kosten per geaccepteerd resultaat = totale workflow-uitgaven ÷ geaccepteerde resultaten. Evalueer dit samen met latentie en kwaliteit nadat je een model, prompt of denkniveau wijzigt.
## Which API Format Should You Use for Gemini 4 Carbon?
Ontwikkelaars hebben toegang tot de [Gemini 4 Carbon API in CometAPI](https://www.cometapi.com/models/google/gemini-4-carbon/) via de native Gemini API en een OpenAI-compatibele Chat API. Gebruik de interface die past bij het aanvraagformaat van je applicatie en de gedocumenteerde eisen aan features.
| Interface | When it fits | Integration check |
| ----------------------------- | ---------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- |
| Gemini-native GenerateContent | De Python- en REST-voorbeelden in deze gids; applicaties die al contents en generationConfig gebruiken | Gebruik de Gemini-base-URL en veldnamen zoals hierboven weergegeven |
| OpenAI-compatible Chat API | Een bestaande applicatie die rond chatberichten is georganiseerd | Controleer het gedocumenteerde endpoint, de velden en de ondersteunde features van de Carbon-route voordat je code aanpast |
Compatibiliteit geldt voor een specifiek endpoint en requestvorm. Stuur geen OpenAI Responses-velden naar het Gemini-native endpoint, en ga er niet van uit dat een Chat-compatibele route ook Responses implementeert. Een applicatie met tools heeft een geverifieerde round trip nodig van een function call naar het bijbehorende resultaat, niet alleen een succesvolle tekstprompt.
## How to Migrate from Gemini 4 Argon to Gemini 4 Carbon API?
Als je Argon-applicatie al de Gemini-native GenerateContent-route van CometAPI gebruikt, begin dan met het overschakelen van het geconfigureerde model naar gemini-4-carbon. Laat sleutel, base-URL, prompt en validatielogica ongewijzigd voor de eerste vergelijking. Zowel [Argon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-argon) als [Carbon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-carbon) delen veel Gemini 4-aanvraagconventies; opschoning van legacy-parameters is alleen nodig als die velden nog in je applicatie staan.
### 1. Change the model and run a controlled comparison
In de setup die in deze gids wordt gebruikt, wijzig COMETAPI_MODEL van gemini-4-argon naar gemini-4-carbon en herstart vervolgens het Python-proces zodat de variabele opnieuw wordt geladen. Gebruik voor beide modellen dezelfde representatieve prompt en hetzelfde denkniveau. Het onderstaande zelfstandige voorbeeld hergebruikt carbon_client.py en selecteert expliciet Carbon:
from carbon_client import client, types, completed_text
response = client.models.generate_content(
model="gemini-4-carbon",
contents="Review this function for correctness: def add(a, b): return a + b",
config=types.GenerateContentConfig(
max_output_tokens=4096,
thinking_config=types.ThinkingConfig(thinking_level="MEDIUM"),
),
)
print(completed_text(response))
### 2. Check request settings and conversation history
Behoud LOW, MEDIUM of HIGH op GenerateContent. Verwijder eventuele overgebleven thinking_budget, MINIMAL of expliciet gebruik van cached_content. Vertrouw niet op temperature, top_p of top_k om het resultaat te sturen. Verwijder frequency_penalty, presence_penalty en candidate_count-waarden boven 1. Als je tools aanroept, behoud overeenkomende function-call-ID’s, namen en responsevolgorde. Dit zijn compatibiliteitscontroles, geen features die nieuw uit Argon zijn verwijderd.
### 3. Validate quality, cost, and latency before rollout
Voer dezelfde testset door beide modellen. Controleer taaksucces, JSON-validatie, toolexecutie, volledige voltooiing, gefactureerde tokens en verstreken tijd. Houd de Argon-configuratie beschikbaar, routeer een klein deel van het verkeer naar Carbon en breid pas uit als het aan je acceptatie- en budgetdoelen voldoet.
### 4. Keep long-output support separate from the model switch
Begin met verzoeken die in één foregroundsegment voltooid worden. Als je een vervolg nodig hebt, verifieer eerst dat CometAPI het vereiste endpoint en de responsevelden ondersteunt. Alleen een wijziging van de modelnaam activeert Google’s v1beta1-vervolgworkflow niet op de v1beta-gateway van deze gids. Laat gedeeltelijke output onvolledig totdat de generatie normaal eindigt.
## Conclusion
Gebruik het eerste succesvolle verzoek als startpunt voor een integratietest. Voeg alleen de inputtypen en responseformaten toe die je applicatie nodig heeft en controleer vervolgens volledige outputs, foutafhandeling en kosten op representatieve taken. Routeer een klein deel van het verkeer via de nieuwe integratie voordat je uitbreidt, en houd een bekende werkende configuratie beschikbaar als de resultaten veranderen.
## Gemini 4 Carbon FAQ
### How large is Gemini 4 Carbon's context window?
Gemini 4 Carbon ondersteunt een geünificeerde input-en-outputcontextlimiet van 1.048.576 tokens. Dit budget omvat input, redenering, function calls en gegenereerde output.
### What are Gemini 4 Carbon's strongest benchmarks?
De opvallende gerapporteerde resultaten omvatten 88,2% op SEC-bench Pro, 54,8% op ExploitGym, 71,0% op CWE-bench en 96,2% op GraphWalks. Deze resultaten benadrukken de cybersecurity-, lang-context- en agentische redeneringscapaciteiten.
### How does Gemini 4 Carbon compare with Gemini 4 Argon?
Carbon verbetert aanzienlijk ten opzichte van Argon op verschillende gerapporteerde benchmarks, waaronder Artificial Analysis Intelligence Index (59 vs. 50), SWE-sweep (9,6% vs. 4,3%) en SEC-bench Pro (88,2% vs. 83,4%). Het primaire onderscheid is sterkere prestaties op uitgebreide redenering en complexe agentische taken.
### Is Gemini 4 Carbon better than Claude Opus 5.5?
Geen van beide modellen leidt elke benchmark. Carbon scoort hoger op Artificial Analysis Intelligence Index, Terminal-Bench 4.0, GraphWalks en cybersecurity-evaluaties, terwijl Claude Opus 5.5 leidt op OSWorld-2.1 en FrontierSWE 2 in Google’s gepubliceerde vergelijking.
### What thinking levels does Gemini 4 Carbon support?
Gemini 4 Carbon ondersteunt LOW, MEDIUM en HIGH denkniveaus, met MEDIUM als standaard. Ontwikkelaars kunnen deze instellingen gebruiken om denkdiepte, latentie en tokenverbruik in balans te brengen.
### Can Gemini 4 Carbon process images, audio, and video?
Ja. De modelkaart vermeldt tekst, afbeeldingen, audio en video als ondersteunde inputmodaliteiten. De gedocumenteerde outputmodaliteit is tekst.
### What is Gemini 4 Carbon's knowledge cutoff?
De modelkaart van Google van november 2026 vermeldt maart 2026 als de kennisgrens. Het model kan daarom kennis tekortkomen over gebeurtenissen en ontwikkelingen na die datum, tenzij die via externe tools of door de gebruiker geleverde context worden aangeleverd.

