TL;DR
Usa la Gemini 4 Carbon API in CometAPI per aggiungere ragionamento e analisi di documenti alla tua applicazione tramite l'interfaccia nativa GenerateContent di Gemini. Inizia con una breve richiesta di testo, verifica che la generazione sia terminata e salva la risposta prima di aggiungere input PDF, immagini, streaming o JSON strutturato. Questa guida fornisce il setup e il codice di gestione delle risposte per ciascun passaggio.
Key Takeaways
- ID modello:
gemini-4-carbon. Nessun livello gratuito — richiede Gemini API a pagamento / Cloud Billing. - Finestra unificata da 1M token (input + thinking + output). Output massimo predefinito ~65K; long decode estende quasi a 1M.
- Livelli di thinking:
low(veloce/economico),medium(predefinito, bilanciato),high(ragionamento profondo). - Prezzo introduttivo fino al 30 novembre 2026: $2 / $10 per 1M token (input in cache $0,10). Raddoppia il 1° dicembre.
- Eccellente per coding agentico a lungo orizzonte, ragionamento scientifico, knowledge work e cybersecurity.
- SDK ufficiali (google-genai) + endpoint compatibili con OpenAI disponibili.
- CometAPI offre l’accesso in produzione più semplice con una singola chiave, tariffe competitive e cambio fluido tra Gemini 4 Carbon, Claude e oltre 500 altri modelli.
Artwork di lancio di Gemini 4 Carbon. Immagine: Google. Opera originale.
What Is Gemini 4 Carbon API?
Gemini 4 Carbon è il modello di punta di Google per workflow agentici a lungo orizzonte, ingegneria software complessa, cybersecurity e ricerca scientifica. Basato su Gemini 4 Argon, utilizza un ragionamento più profondo e cicli di verifica estesi per affrontare task multi-step che richiedono problem solving prolungato piuttosto che una singola risposta. Rispetto ad Argon, Carbon è progettato per carichi più esigenti in cui accuratezza e completamento del task contano più della minimizzazione dei token. Google ha annunciato l’accesso a pagamento per sviluppatori il 10 novembre 2026. Il suo supporto multimodale input consente di combinare testo con input visivi e altri media; l’output generato è testo. CometAPI offre accesso API scontato.
Per un’integrazione API, inizia con un singolo task il cui risultato puoi verificare: riassumere un documento, estrarre campi da una nota di incidente o rivedere uno screenshot. Un workflow agentico più ampio può basarsi su quella richiesta funzionante una volta verificate le funzionalità supportate dal percorso e il comportamento della risposta.
Other Ways to Use It
- Google AI Studio Playground: Seleziona il modello e prova i prompt in modo interattivo (richiede accesso a pagamento per Carbon).
- Gemini app / AI Mode / Antigravity: Disponibile se hai Google AI Ultra (seleziona il modello dove previsto).
- Enterprise / Cloud: Usa tramite Gemini Enterprise Agent Platform o endpoint in stile Vertex con lo stesso ID modello (setup di progetto + location).
- Gli scienziati/ricercatori possono richiedere accesso gratuito limitato in alcuni casi.
What Are the Gemini 4 Carbon API Specifications ?
Le specifiche ufficiali del modello distinguono il budget di contesto condiviso dal limite di output di ciascun segmento in foreground. Questi sono limiti a livello di modello; anche il tuo gateway può applicare restrizioni su dimensione richieste e funzionalità.
Limitations and API Considerations
Prima di espandere l’integrazione, verifica come Carbon gestisce contesto, impostazioni di generazione, caching e accesso. La tabella mette in relazione ciascun vincolo con un’azione pratica per evitare richieste non valide, risultati incompleti e costi inattesi.
La guida per sviluppatori di Carbon documenta le regole API; la sua model card descrive affidabilità e limitazioni per accessi specializzati. Conferma le funzionalità corrispondenti sul tuo percorso CometAPI prima di abilitarle in produzione.
Thinking Levels: How to Choose the Right Setting
Inizia con MEDIUM, quindi regola il livello in base al task e alla qualità necessaria.
- LOW: Usalo per estrazioni semplici, classificazione e riassunti quando priorità sono tempo di risposta e costo. Provalo per task come l’etichettatura di ticket di supporto e verifica che soddisfi il tuo target di accuratezza.
- MEDIUM: Punto di partenza predefinito per coding quotidiano, analisi documenti e ragionamento ordinario. È una base pratica per valutare se un livello diverso migliora la tua applicazione.
- HIGH: Usalo per debugging complesso, ricerca multi-step e ragionamento scientifico che beneficiano di un’indagine più profonda. Prevedi token aggiuntivi per il reasoning e mantienilo solo quando il guadagno di qualità giustifica costo e tempo extra.
Livelli di thinking più alti non garantiscono automaticamente risultati migliori per ogni task. Valuta i tuoi workload e confronta qualità di completamento, latenza e uso totale di token prima di modificare i default in produzione.
How Does Gemini 4 Carbon Perform on AI Benchmarks?
Selected Benchmark Results
Le pagine Artificial Analysis Carbon (High) e Argon (High) mostrano il seguente snapshot, verificato il 12 novembre 2026. Questi sono risultati di benchmark, non misure di latenza di CometAPI.
I totali dei token di output coprono l’intera valutazione, non una singola richiesta. Il costo per task usa le ipotesi di pricing di Artificial Analysis anziché lo sconto corrente di CometAPI. Carbon attende più a lungo prima del primo token di risposta, ma completa il task di benchmark più rapidamente e a costo riportato inferiore; il volume di token da solo non determina il valore.
Usa Carbon quando la sua verifica più profonda migliora revisioni di codice difficili, ricerca o altro lavoro in cui gli errori costano caro. Prova Argon per coding e knowledge task di routine, ma conferma i risparmi sul tuo workload. Esegui prompt identici e confronta la spesa totale divisa per i risultati accettati, insieme a tempi di completamento e tasso di errore.
How Do You start with the Gemini 4 Carbon API in CometAPI?
Avrai bisogno di un account CometAPI con accesso al modello e credito sufficiente, di un ambiente Python e di una familiarità di base con l’esecuzione di script. Usa una directory di progetto per i file sottostanti così ogni esempio può importare la stessa configurazione del client.
Why Use Gemini 4 Carbon API Through CometAPI?
CometAPI è utile quando vuoi valutare Carbon insieme ad altri modelli gestendo accesso e fatturazione tramite un unico provider. Il suo percorso Carbon offre sia GenerateContent nativo Gemini sia un’interfaccia Chat compatibile con OpenAI, così puoi scegliere il formato di richiesta adatto alla tua applicazione.
Per questa guida, il percorso nativo consente di riutilizzare l’SDK Google Gen AI con una chiave e una base URL CometAPI. I prezzi dell’attuale gruppo predefinito sono inferiori del 20% rispetto alle tariffe introduttive di Google. Mantieni l’ID modello in configurazione così puoi confrontare Carbon e Argon senza riscrivere l’applicazione, e verifica il supporto specifico del percorso prima di aggiungere tool, upload di file o continuazioni lunghe.
Step 1: Create Your Account and Set Your API Key
Accedi a CometAPI, crea o apri la tua chiave API e memorizzala come variabile d’ambiente. Evita di inserire le chiavi direttamente nel codice sorgente o di committarle in un repository.
Usa il comando per la tua shell. Imposta le variabili nello stesso terminale che userai per eseguire Python; sostituisci il placeholder della chiave con la tua chiave.
Imposta chiave e modello in PowerShell.
$env:COMETAPI_KEY = "YOUR_COMETAPI_KEY"
$env:COMETAPI_MODEL = "gemini-4-carbon"
Imposta chiave e modello in Bash.
export COMETAPI_KEY="YOUR_COMETAPI_KEY"
export COMETAPI_MODEL="gemini-4-carbon"
Step 2: Install the SDK and Configure the Endpoint
Installa l’SDK nel tuo ambiente di progetto. Usare python -m pip mantiene l’installer legato all’interprete che eseguirà l’esempio.
Installa o aggiorna il Google Gen AI SDK.
python -m pip install --upgrade google-genai
CometAPI documenta un endpoint nativo Gemini con una base URL personalizzata per l’SDK. Usa la tua chiave CometAPI per questo endpoint. Le impostazioni sottostanti si applicano alle richieste GenerateContent.
Step 3: Create a Reusable Client and Validate Responses
Salva questo setup come carbon_client.py. Definisce il client una volta e fornisce completed_text per le risposte testuali usate in questa guida. L’helper controlla la candidate finish reason prima di restituire il testo della risposta, così un risultato vuoto o troncato non viene trattato silenziosamente come successo.
Crea carbon_client.py con il client CometAPI e un validatore di risposte testuali.
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
Crea first_request.py accanto a carbon_client.py e aggiungi il codice sottostante. Invia un breve prompt di checklist usando thinking MEDIUM e un budget di output di 4.096 token, verifica il completamento con completed_text(response) e salva la risposta in answer.txt come UTF-8. Esegui python first_request.py dalla directory del progetto, poi apri answer.txt e conferma che tutti e cinque i punti di revisione siano pertinenti e utili. Controlla i metadati di utilizzo stampati per il consumo dei token, incluso il thinking; un termine normale non garantisce la qualità della risposta. Se la richiesta fallisce o restituisce output incompleto, usa la sezione di troubleshooting per controllare credenziali, dettagli d’errore e finish reason prima di ritentare.
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?
Esegui questi esempi dalla stessa directory di carbon_client.py. Caricano file locali in parti di contenuto inline, mantenendo il workflow iniziale indipendente da un servizio separato di upload file.
La comprensione dei PDF include contenuti visivi: Gemini può interpretare testo, tabelle, grafici e immagini insieme. La [guida di Google alla elaborazione di documenti](https://ai.google.dev/gemini-api/docs/document-processing) descrive il supporto per PDF fino a 1.000 pagine, soggetto a limiti di dimensione file e contesto. Il conteggio pagine è un tetto massimo, non una garanzia che ogni documento rientrerà in una richiesta del gateway.
Usa input inline per PDF piccoli e temporanei. Per file più grandi o domande multi-turn ripetute, Google consiglia la Files API per evitare di reinviare l’intero file. Prima di usare quel workflow tramite CometAPI, verifica il suo endpoint di upload e il supporto per i riferimenti a file; l’esempio inline seguente resta un punto di partenza pratico.
### Summarize a local PDF
Google documenta [input PDF inline](https://ai.google.dev/gemini-api/docs/document-processing) per GenerateContent. Posiziona un piccolo report.pdf non sensibile nella directory del progetto, poi salva quanto segue come analyze_pdf.py ed esegui python analyze_pdf.py.
Invia un PDF locale e salva il suo riassunto completato.
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)
Confronta il riassunto con il file prima di estendere a documenti più grandi. I limiti sulla dimensione della richiesta e il supporto per riferimenti a file dipendono dal gateway. Il supporto di Google per formati Office o riferimenti a Cloud Storage non stabilisce di per sé il supporto per tali input tramite il tuo percorso CometAPI.
### Review a local screenshot
Per [input immagine inline](https://ai.google.dev/gemini-api/docs/image-understanding), fai corrispondere il MIME type al file. Posiziona uno screenshot PNG chiamato screen.png accanto allo script. Salva questo esempio come analyze_image.py ed esegui python analyze_image.py per rivedere testo visibile e layout.
Analizza uno screenshot PNG senza affidarti a un URL pubblico dell’immagine.
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))
Confronta ogni problema riportato con lo screenshot. Se invii un JPEG, cambia sia il nome file sia il MIME type per corrispondere; cambiare solo l’estensione non converte l’immagine.
## How Do You Stream Gemini 4 Carbon Responses ?
### Display streamed text and check completion
Lo streaming restituisce chunk di risposta come server-sent events (SSE), consentendo a un’applicazione di visualizzare output parziale mentre la generazione continua.
L’SDK espone la [generazione di testo in streaming](https://ai.google.dev/gemini-api/docs/text-generation) tramite generate_content_stream. Per richieste HTTP dirette, CometAPI usa streamGenerateContent con alt=sse.
Salva quanto segue come stream_response.py ed esegui python stream_response.py. Mostra il testo man mano che arriva, quindi verifica che lo stream sia terminato con una finish reason normale. Un’eccezione lascia il testo mostrato come risultato parziale, non come risposta accettata.
Leggi testo in streaming e richiedi una fine normale prima di accettarlo.
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
Per [output vincolato da schema](https://ai.google.dev/gemini-api/docs/structured-output), richiedi application/json e definisci i campi attesi dalla tua applicazione. Questo esempio estrae due campi da una breve nota di incidente, quindi verifica i loro tipi prima di stampare il risultato.
Salva questo esempio come structured_output.py ed esegui python structured_output.py. Riutilizza il validatore di risposta prima di analizzare il JSON.
Estrai i campi dell’incidente, verifica il completamento e valida i loro tipi.
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))
Dovresti ricevere un oggetto contenente service e impact. La conformità allo schema non stabilisce l’accuratezza fattuale: confronta i valori estratti con l’input e applica eventuali regole aziendali prima di memorizzare o agire sul risultato.
## Gemini 4 Carbon API Price
Il [pricing introduttivo di Google](https://blog.google/innovation-and-ai/models/gemini-models/gemini-4-carbon-now-available/) dura fino al 30 novembre 2026; le tariffe standard entrano in vigore il 1° dicembre. Verifica le tariffe correnti del tuo account prima di pianificare richieste future.
Entrambi i modelli appartengono alla famiglia Gemini 4, ma indirizzano workload diversi.
| API pricing tier | Input / 1M token | Output / 1M token |
| ------------------------- | ---------------- | ----------------- |
| Standard (fino al 30 nov) | $2,00 | $10,00 |
| Standard (dal 1 dic) | $4,00 | $20,00 |
| Batch (fino al 30 nov) | $1,00 | $5,00 |
| Batch (dal 1 dic) | $2,00 | $10,00 |
| Flex (fino al 30 nov) | $1,00 | $5,00 |
| Priority (fino al 30 nov) | $3,60 | $18,00 |
Dettagli di prezzo aggiuntivi:
* Input in cache: $0,10 per milione di token fino al 30 novembre, aumentando a $0,20 dal 1° dicembre.
* Batch e Flex offrono elaborazione a costo inferiore per workload che possono tollerare le loro caratteristiche di servizio.
* I token di thinking sono fatturati come token di output.
* Anche i token consumati da istruzioni di tool interni e dichiarazioni di funzioni possono essere fatturabili.
Google raccomanda esplicitamente Argon per la maggior parte del lavoro di ingegneria software e knowledge, riservando Carbon a task che richiedono ragionamento più profondo e verifica estesa.
Raccomandazione pratica: Scegli Carbon quando il costo di un risultato errato è alto o quando un task richiede esplorazione e verifica sostanziali. Scegli Argon quando ti serve un forte ragionamento con un budget di token più efficiente.
### CometAPI Price
Verificato il 12 novembre 2026, la [schedule del gruppo predefinito di CometAPI](https://www.cometapi.com/models/google/gemini-4-carbon/) elenca $1,60 per milione di token in input, $8,00 per milione di token in output incluso il thinking, e $0,08 per milione di token di input in cache su cache hit. Queste tariffe sono inferiori del 20% rispetto alle tariffe introduttive corrispondenti di Google.
Il pricing di CometAPI può cambiare man mano che cambiano le tariffe ufficiali di Google. Confronta la tariffa ufficiale corrente con lo sconto associato al tuo account invece di considerare il prezzo in dollari di oggi come permanente. Se lo stesso sconto del 20% viene mantenuto dopo una modifica delle tariffe, la tua tariffa è la nuova tariffa ufficiale × 0,80; conferma la tariffa CometAPI effettiva prima di pianificare il budget. Altri gruppi account possono avere sconti diversi.
Per una richiesta con 100.000 token di input non in cache e 10.000 token di output, incluso il thinking, il costo dei soli token è $0,24 alla tariffa CometAPI mostrata: $0,16 per l’input più $0,08 per l’output. Le stesse quantità costano $0,30 alle tariffe introduttive di Google o $0,60 alle tariffe di dicembre. I 110.000 token combinati rientrano nel budget condiviso del modello.
Questa stima esclude tool, retry e qualsiasi adeguamento specifico dell’account. Il costo dell’output include i token di thinking, quindi un livello di ragionamento più alto può aumentare il conto anche se la risposta visibile è breve.
### How to Optimize Gemini 4 Carbon API Costs?
Ottimizza per il costo di un risultato corretto e utilizzabile. Una richiesta più economica è di scarso valore se devi ripeterla o correggere manualmente la risposta.
1. Scegli deliberatamente il ragionamento. Inizia con MEDIUM, testa LOW per lavori semplici e usa HIGH quando migliora il tasso di accettazione abbastanza da giustificare tempo e token aggiuntivi.
2. Riutilizza contesti stabili tramite caching implicito. I workflow di [Argon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-argon) e [Carbon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-carbon) non supportano la creazione esplicita della context cache; supportano il caching implicito. Metti istruzioni e documenti riutilizzabili per primi, seguiti dalla domanda variabile. Google documenta l’idoneità per prefissi condivisi di almeno 4.096 token. Verifica effettivi cache hit e addebiti sul tuo percorso CometAPI; la ripetizione non garantisce uno sconto.
3. Riduci il lavoro non necessario. Invia pagine o estratti rilevanti, richiedi i campi di output di cui hai bisogno e imposta un budget di output sufficiente. Il thinking conta verso l’uso di output, quindi un cap troppo basso può causare troncamenti e retry.
4. Misura l’intero workflow. Includi ragionamento, uso di tool, retry e risposte rifiutate nella spesa totale. Salva le risposte valide così i fallimenti di storage a valle non generano un’altra generazione.
5. Instrada in base al valore dimostrato. Confronta Carbon e Argon sugli stessi task. Considera Batch o Flex solo quando il tuo provider li supporta e il workload può tollerare le loro caratteristiche di elaborazione.
Traccia costo per risultato accettato = spesa totale del workflow ÷ risultati accettati. Rivedilo insieme a latenza e qualità dopo aver cambiato modello, prompt o livello di ragionamento.
## Which API Format Should You Use for Gemini 4 Carbon?
Gli sviluppatori possono accedere alla [Gemini 4 Carbon API in CometAPI](https://www.cometapi.com/models/google/gemini-4-carbon/) tramite la API nativa di Gemini e una Chat API compatibile con OpenAI. Usa l’interfaccia che corrisponde al formato di richiesta della tua applicazione e ai requisiti funzionali documentati.
| Interface | When it fits | Integration check |
| ----------------------------- | ---------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- |
| Gemini-native GenerateContent | Gli esempi Python e REST in questa guida; applicazioni che già usano contents e generationConfig | Usa la base URL Gemini e i nomi campo mostrati sopra |
| OpenAI-compatible Chat API | Un’applicazione esistente organizzata attorno a messaggi di chat | Verifica endpoint, campi e funzionalità supportate del percorso Carbon prima di adattare il codice |
La compatibilità si applica a un particolare endpoint e forma di richiesta. Non inviare campi OpenAI Responses all’endpoint nativo Gemini, né presumere che un percorso compatibile con Chat implementi anche Responses. Un’applicazione abilitata ai tool necessita di un round trip verificato da una function call al risultato corrispondente, non solo di un prompt testuale andato a buon fine.
## How to Migrate from Gemini 4 Argon to Gemini 4 Carbon API?
Se la tua applicazione Argon usa già il percorso GenerateContent nativo Gemini di CometAPI, inizia cambiando il modello configurato in **gemini-4-carbon**. Mantieni invariati chiave, base URL, prompt e logica di validazione per il primo confronto. Sia [Argon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-argon) sia [Carbon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-carbon) condividono molte convenzioni di richiesta Gemini 4; la pulizia dei parametri legacy è necessaria solo se quei campi sono ancora nella tua applicazione.
### 1. Change the model and run a controlled comparison
Nel setup usato in questa guida, cambia COMETAPI_MODEL da gemini-4-argon a gemini-4-carbon, poi riavvia il processo Python così ricarica la variabile. Usa lo stesso prompt rappresentativo e livello di thinking per entrambi i modelli. Il seguente esempio standalone riutilizza carbon_client.py e seleziona esplicitamente 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
Mantieni LOW, MEDIUM o HIGH su GenerateContent. Rimuovi eventuali residui di thinking_budget, MINIMAL o l’uso esplicito di cached_content. Non fare affidamento su temperature, top_p o top_k per controllare il risultato. Rimuovi frequency_penalty, presence_penalty e valori candidate_count superiori a 1. Se chiami tool, preserva gli ID delle function call corrispondenti, i nomi e l’ordine delle risposte. Questi sono controlli di compatibilità, non funzionalità di recente rimozione da Argon.
### 3. Validate quality, cost, and latency before rollout
Esegui lo stesso set di test su entrambi i modelli. Controlla successo del task, validazione JSON, esecuzione dei tool, completamento pieno, token fatturati e tempo trascorso. Mantieni disponibile la configurazione Argon, instrada una piccola parte del traffico su Carbon ed espandi solo se soddisfa i tuoi obiettivi di accettazione e budget.
### 4. Keep long-output support separate from the model switch
Inizia con richieste che terminano in un segmento in foreground. Se ti serve una continuazione, conferma prima che CometAPI supporti l’endpoint e i campi di risposta richiesti. Un cambio di nome modello da solo non abilita il workflow di continuazione v1beta1 di Google sul gateway v1beta di questa guida. Mantieni l’output parziale incompleto finché la generazione non termina normalmente.
## Conclusion
Usa la prima richiesta andata a buon fine come punto di partenza per un test di integrazione. Aggiungi solo i tipi di input e i formati di risposta necessari alla tua applicazione, quindi verifica output completi, gestione degli errori e costo su task rappresentativi. Instrada una piccola quota di traffico tramite la nuova integrazione prima di espanderla e mantieni una configurazione funzionante nota disponibile se i risultati cambiano.
## Gemini 4 Carbon FAQ
### How large is Gemini 4 Carbon's context window?
Gemini 4 Carbon supporta un limite unificato di contesto input-e-output di 1.048.576 token. Questo budget include input, ragionamento, function call e output generato.
### What are Gemini 4 Carbon's strongest benchmarks?
I suoi risultati di punta riportati includono 88,2% su SEC-bench Pro, 54,8% su ExploitGym, 71,0% su CWE-bench e 96,2% su GraphWalks. Questi risultati evidenziano le sue capacità in cybersecurity, long-context e ragionamento agentico.
### How does Gemini 4 Carbon compare with Gemini 4 Argon?
Carbon migliora sensibilmente rispetto ad Argon su diversi benchmark riportati, inclusi Artificial Analysis Intelligence Index (59 vs. 50), SWE-sweep (9,6% vs. 4,3%) e SEC-bench Pro (88,2% vs. 83,4%). La sua distinzione principale è una performance più forte su ragionamenti estesi e task agentici complessi.
### Is Gemini 4 Carbon better than Claude Opus 5.5?
Nessun modello guida ogni benchmark. Carbon ottiene punteggi più alti su Artificial Analysis Intelligence Index, Terminal-Bench 4.0, GraphWalks e valutazioni di cybersecurity, mentre Claude Opus 5.5 guida OSWorld-2.1 e FrontierSWE 2 nel confronto pubblicato da Google.
### What thinking levels does Gemini 4 Carbon support?
Gemini 4 Carbon supporta i livelli LOW, MEDIUM e HIGH, con MEDIUM come predefinito. Gli sviluppatori possono usare queste impostazioni per bilanciare profondità di ragionamento, latenza e consumo di token.
### Can Gemini 4 Carbon process images, audio, and video?
Sì. La sua model card elenca testo, immagini, audio e video come modalità di input supportate. La modalità di output documentata è il testo.
### What is Gemini 4 Carbon's knowledge cutoff?
La model card di novembre 2026 di Google indica marzo 2026 come knowledge cutoff. Il modello può quindi non conoscere eventi e sviluppi successivi a tale data a meno che non vengano forniti tramite tool esterni o contesto fornito dall’utente.
##