Bangun dengan CometAPIButuh satu API untuk banyak model?Uji alur kerja di Playground, lalu buat API key saat model dan biayanya sesuai dengan use case Anda.
Gunakan Gemini 4 Carbon API di CometAPI untuk menambahkan penalaran dan analisis dokumen ke aplikasi Anda melalui antarmuka GenerateContent asli Gemini. Mulailah dengan permintaan teks pendek, pastikan generasi selesai, dan simpan jawabannya sebelum menambahkan input PDF, gambar, streaming, atau JSON terstruktur. Panduan ini menyediakan kode penyiapan dan penanganan respons untuk setiap langkah.
Key Takeaways
ID model: gemini-4-carbon. Tidak ada tingkat gratis — memerlukan Gemini API berbayar / Cloud Billing.
Jendela 1M token terpadu (input + thinking + output). Batas output default ~65K; long decode memperpanjang hingga hampir 1M.
Tingkat pemikiran: (cepat/hemat), (default, seimbang), (penalaran mendalam).
Ditinjau untuk kejelasan, atribusi sumber, dan terminologi API terkini.
low
medium
high
Harga perkenalan hingga 30 Nov 2026: $2 / $10 per 1M token (input cache $0.10). Menjadi dua kali lipat pada 1 Des.
Sangat baik untuk coding agen berjangka panjang, penalaran ilmiah, pekerjaan pengetahuan, dan tugas keamanan siber.
SDK resmi (google-genai) + endpoint kompatibel OpenAI tersedia.
CometAPI menawarkan akses produksi termudah dengan satu kunci, tarif kompetitif, dan perpindahan mulus antara Gemini 4 Carbon, Claude, dan 500+ model lainnya.
Karya peluncuran Gemini 4 Carbon. Gambar: Google. Karya asli.
What Is Gemini 4 Carbon API?
Gemini 4 Carbon adalah model penalaran frontier dari Google untuk alur kerja agen berjangka panjang, rekayasa perangkat lunak kompleks, keamanan siber, dan penelitian ilmiah. Dibangun di atas Gemini 4 Argon, model ini menggunakan penalaran yang lebih dalam dan loop verifikasi yang diperluas untuk menangani tugas multi-langkah yang memerlukan pemecahan masalah berkelanjutan alih-alih satu respons. Dibandingkan dengan Argon, Carbon dirancang untuk beban kerja yang lebih menuntut di mana akurasi dan penyelesaian tugas lebih penting daripada meminimalkan penggunaan token. Google mengumumkan akses pengembang berbayar pada 10 November 2026. Dukungan input multimodal memungkinkan Anda menggabungkan teks dengan visual dan media lainnya; output yang dihasilkan adalah teks. CometAPI menawarkan akses API dengan diskon.
Untuk integrasi API, mulailah dengan satu tugas yang hasilnya dapat Anda periksa: meringkas dokumen, mengekstrak kolom dari catatan insiden, atau meninjau tangkapan layar. Alur kerja agen yang lebih luas dapat dibangun di atas permintaan yang berfungsi setelah Anda memverifikasi alat yang didukung rute dan perilaku responsnya.
Other Ways to Use It
Google AI Studio Playground: Pilih model dan uji prompt secara interaktif (memerlukan akses berbayar untuk Carbon).
Aplikasi Gemini / AI Mode / Antigravity: Tersedia jika Anda memiliki Google AI Ultra (pilih model di tempat yang disediakan).
Enterprise / Cloud: Gunakan melalui Gemini Enterprise Agent Platform atau endpoint bergaya Vertex dengan ID model yang sama (penyiapan project + location).
Ilmuwan/peneliti dapat mengajukan akses gratis terbatas dalam beberapa kasus.
What Are the Gemini 4 Carbon API Specifications ?
Spesifikasi model resmi membedakan anggaran konteks bersama dari batas output setiap segmen foreground. Ini adalah batas di tingkat model; gateway Anda juga dapat menerapkan pembatasan ukuran permintaan dan fitur.
Limitations and API Considerations
Sebelum memperluas integrasi, periksa bagaimana Carbon menangani konteks, pengaturan generasi, caching, dan akses. Tabel ini memasangkan setiap batasan dengan tindakan praktis sehingga Anda dapat menghindari permintaan tidak valid, hasil tidak lengkap, dan biaya tak terduga.
Area
Batasan atau persyaratan
Implikasi untuk pengembang
Unified token budget
Input dan output berbagi 1.048.576 token, termasuk thinking dan function calls.
Sisihkan ruang output sebelum menambahkan riwayat percakapan atau file.
Long decoding
Satu segmen foreground mengizinkan hingga 65.536 token output saat streaming, atau 32.768 tanpa streaming;
generasi lebih panjang memerlukan continuation.
Thinking levels
Low, Medium, High; Medium adalah default
Untuk GenerateContent, kirim LOW, MEDIUM, atau HIGH; MINIMAL ditolak.
Thinking budget
Parameter thinking_budget legacy ditolak
Hapus thinking_budget dari builder permintaan dan gunakan thinking_config.thinking_level di Python, atau thinkingConfig.thinkingLevel di REST JSON.
Sampling
Nilai kustom temperature, top_p, dan top_k diabaikan
Gunakan thinking_level untuk memilih kedalaman penalaran dan response_schema untuk output terstruktur.
Letakkan konteks yang dapat digunakan ulang terlebih dahulu dan pertanyaan yang berubah di bagian akhir. Hapus panggilan pembuatan cache eksplisit dan referensi cached_content
API cost
Thinking tokens ditagihkan sebagai output
Hitung thinking serta output yang terlihat.
Cybersecurity access
Akses siber khusus dibatasi
Periksa kelayakan untuk akses Fairwind khusus. Akses Carbon standar tidak secara otomatis memberikan akses ke varian yang lebih permisif.
Reliability
Halusinasi, timeout sesekali, dan penggunaan token lebih tinggi dapat terjadi
Panduan pengembang Carbon dari Google mendokumentasikan aturan API; model card menjelaskan keandalan dan batasan akses khusus. Konfirmasikan fitur yang sesuai pada rute CometAPI Anda sebelum mengaktifkannya di produksi.
Thinking Levels: How to Choose the Right Setting
Mulailah dengan MEDIUM, lalu sesuaikan level dengan tugas dan kualitas yang Anda butuhkan.
LOW: Gunakan untuk ekstraksi sederhana, klasifikasi, dan ringkasan ketika waktu respons dan biaya menjadi prioritas. Coba untuk tugas seperti pelabelan tiket dukungan, dan pastikan tetap memenuhi target akurasi Anda.
MEDIUM: Gunakan titik awal default ini untuk coding sehari-hari, analisis dokumen, dan penalaran rutin. Ini adalah baseline praktis untuk mengevaluasi apakah level lain meningkatkan aplikasi Anda.
HIGH: Gunakan untuk debugging kompleks, penelitian multi-langkah, dan penalaran ilmiah yang diuntungkan oleh investigasi lebih dalam. Sisihkan token penalaran tambahan, dan pertahankan hanya ketika peningkatan kualitas membenarkan biaya dan waktu ekstra.
Level pemikiran yang lebih tinggi tidak otomatis menjamin hasil yang lebih baik untuk setiap tugas. Benchmark beban kerja Anda sendiri dan bandingkan kualitas penyelesaian tugas, latensi, dan total penggunaan token sebelum mengubah default produksi.
How Does Gemini 4 Carbon Perform on AI Benchmarks?
Selected Benchmark Results
Benchmark
Gemini 4 Carbon
Gemini 4 Argon
GPT-6 Astra
Claude Opus 5.5
Artificial Analysis Intelligence Index v5.0
59
50
57
58
SWE-sweep
9.60%
4.30%
9.50%
3.60%
FrontierSWE 2
61.20%
55.00%
65.50%
62.30%
Terminal-Bench 4.0
65.20%
57.10%
59.10%
59.60%
Agents' Last Exam v1.1
77.40%
69.00%
73.10%
71.60%
OSWorld-2.1
81.50%
74.70%
80.90%
87.20%
AutomationBench
53.90%
51.30%
41.40%
42.50%
Chartography
72.50%
71.60%
71.00%
66.30%
GraphWalks (256K–1M)
96.20%
84.20%
71.80%
66.80%
Halaman Artificial Analysis Carbon (High) dan Argon (High) menampilkan snapshot berikut, diperiksa pada 12 November 2026. Ini adalah hasil benchmark, bukan pengukuran latensi CometAPI.
Metric
Carbon (High)
Argon (High)
Intelligence Index
60
50
Kecepatan output
80 token/dtk
65 token/dtk
Waktu ke token jawaban pertama
67,83 dtk
37,64 dtk
Waktu per tugas Intelligence Index
25,5 mnt
30,0 mnt
Token output sepanjang evaluasi
205M
113M
Biaya per tugas Intelligence Index
$7,76
$9,95
Total token output mencakup evaluasi, bukan satu permintaan. Biaya tugas menggunakan asumsi harga Artificial Analysis, bukan diskon CometAPI saat ini. Carbon menunggu lebih lama sebelum token jawaban pertama, namun menyelesaikan tugas benchmark lebih cepat dan dengan biaya yang dilaporkan lebih rendah; volume token saja tidak menentukan nilai.
Gunakan Carbon ketika verifikasi lebih dalam meningkatkan review kode yang sulit, penelitian, atau pekerjaan lain yang mahal jika salah. Uji Argon untuk coding rutin dan tugas pengetahuan, namun konfirmasikan penghematan pada beban kerja Anda sendiri. Jalankan prompt yang identik dan bandingkan total pengeluaran dibagi hasil yang diterima, bersama waktu penyelesaian dan tingkat kegagalan.
How Do You start with the Gemini 4 Carbon API in CometAPI?
Anda akan memerlukan akun CometAPI dengan akses ke model dan kredit yang cukup, lingkungan Python, dan familiaritas dasar menjalankan skrip. Gunakan direktori proyek untuk file di bawah sehingga setiap contoh dapat mengimpor konfigurasi klien yang sama.
Why Use Gemini 4 Carbon API Through CometAPI?
CometAPI berguna ketika Anda ingin mengevaluasi Carbon bersama model lain sambil mengelola akses dan penagihan melalui satu penyedia. Rute Carbon menawarkan GenerateContent asli Gemini dan antarmuka Chat yang kompatibel dengan OpenAI, sehingga Anda dapat memilih format permintaan yang sesuai dengan aplikasi Anda.
Untuk panduan ini, rute asli memungkinkan Anda menggunakan kembali Google Gen AI SDK dengan kunci dan base URL CometAPI. Harga default-group saat ini 20% di bawah tarif perkenalan Google. Simpan ID model dalam konfigurasi sehingga Anda dapat membandingkan Carbon dan Argon tanpa menulis ulang aplikasi, dan periksa dukungan spesifik rute sebelum menambahkan tools, unggahan file, atau continuation panjang.
Step 1: Create Your Account and Set Your API Key
Masuk ke CometAPI, buat atau buka kunci API Anda, dan simpan sebagai variabel lingkungan. Hindari menaruh kunci langsung di kode sumber atau meng-commit-nya ke repositori.
Gunakan perintah untuk shell Anda. Tetapkan variabel di terminal yang sama yang akan Anda gunakan untuk menjalankan Python; ganti placeholder kunci dengan kunci Anda sendiri.
Step 2: Install the SDK and Configure the Endpoint
Instal SDK di lingkungan proyek Anda. Menggunakan python -m pip menjaga installer terikat pada interpreter yang akan menjalankan contoh.
Instal atau perbarui Google Gen AI SDK.
python -m pip install --upgrade google-genai
CometAPI mendokumentasikan endpoint asli Gemini dengan base URL SDK kustom. Gunakan kunci CometAPI Anda untuk endpoint ini. Pengaturan di bawah berlaku untuk permintaan GenerateContent.
Setting
Value
SDK
google-genai
Base URL
https://api.cometapi.com
API version
v1beta
REST authentication header
x-goog-api-key
Key environment variable
COMETAPI_KEY
Model environment variable
COMETAPI_MODEL
Model ID
gemini-4-carbon
Step 3: Create a Reusable Client and Validate Responses
Simpan penyiapan ini sebagai carbon_client.py. File ini mendefinisikan klien sekali dan menyediakan completed_text untuk respons teks saja yang digunakan dalam panduan ini. Helper memeriksa candidate finish reason sebelum mengembalikan teks jawaban, sehingga hasil kosong atau terpotong tidak diam-diam dianggap sukses.
Buat carbon_client.py dengan klien CometAPI dan validator respons teks.
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
Buat first_request.py di samping carbon_client.py dan tambahkan kode di bawah. Skrip ini mengirim prompt checklist pendek menggunakan pemikiran MEDIUM dan anggaran output 4.096 token, memeriksa penyelesaian dengan completed_text(response), dan menyimpan jawabannya ke answer.txt sebagai UTF-8. Jalankan python first_request.py dari direktori proyek Anda, lalu buka answer.txt dan konfirmasikan bahwa kelima poin peninjauan relevan dan dapat digunakan. Periksa metadata penggunaan yang dicetak untuk konsumsi token, termasuk thinking; penyelesaian normal tidak menetapkan kualitas jawaban. Jika permintaan gagal atau mengembalikan output tidak lengkap, gunakan bagian troubleshooting untuk memeriksa kredensial, detail error, dan finish reason sebelum mencoba lagi.
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?
Jalankan contoh ini dari direktori yang sama dengan carbon\_client.py. Contoh ini memuat file lokal ke dalam part konten inline, menjaga alur kerja awal tetap independen dari layanan unggah file terpisah.
Pemahaman PDF mencakup konten visual: Gemini dapat menafsirkan teks, tabel, grafik, dan gambar bersama-sama. [Panduan pemrosesan dokumen Google](https://ai.google.dev/gemini-api/docs/document-processing) menjelaskan dukungan untuk PDF hingga 1.000 halaman, tergantung pada batas ukuran file dan konteks. Jumlah halaman adalah batas atas, bukan jaminan bahwa setiap dokumen akan pas dalam permintaan gateway.
Gunakan input inline untuk PDF kecil dan sementara. Untuk file lebih besar atau pertanyaan multi-giliran berulang, Google merekomendasikan Files API guna menghindari pengiriman ulang file penuh. Sebelum menggunakan alur kerja tersebut melalui CometAPI, verifikasi endpoint unggah dan dukungan referensi file; contoh inline di bawah ini tetap menjadi titik awal yang praktis.
### Summarize a local PDF
Google mendokumentasikan [input PDF inline](https://ai.google.dev/gemini-api/docs/document-processing) untuk GenerateContent. Tempatkan report.pdf kecil dan non-sensitif di direktori proyek, lalu simpan berikut sebagai analyze\_pdf.py dan jalankan python analyze\_pdf.py.
Kirim PDF lokal dan simpan ringkasannya yang selesai.
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),
)
Bandingkan ringkasan dengan file sebelum memperluas ke dokumen yang lebih besar. Batas ukuran permintaan dan dukungan referensi file bergantung pada gateway. Dukungan Google untuk format Office atau referensi Cloud Storage tidak secara otomatis menetapkan dukungan untuk input tersebut melalui rute CometAPI Anda.
### Review a local screenshot
Untuk [input gambar inline](https://ai.google.dev/gemini-api/docs/image-understanding), cocokkan tipe MIME dengan filenya. Tempatkan PNG screenshot bernama screen.png di samping skrip. Simpan contoh ini sebagai analyze\_image.py dan jalankan python analyze\_image.py untuk meninjau teks dan tata letak yang terlihat.
Analisis screenshot PNG tanpa bergantung pada URL gambar publik.
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))
Bandingkan setiap isu yang dilaporkan dengan screenshot. Jika Anda mengirim JPEG, ubah nama file dan tipe MIME agar cocok; mengubah ekstensi saja tidak mengonversi gambar.
## How Do You Stream Gemini 4 Carbon Responses ?
### Display streamed text and check completion
Streaming mengembalikan potongan respons sebagai server-sent events (SSE), memungkinkan aplikasi menampilkan output parsial saat generasi berlanjut.
SDK mengekspos [streaming text generation](https://ai.google.dev/gemini-api/docs/text-generation) melalui generate\_content\_stream. Untuk permintaan HTTP langsung, CometAPI menggunakan streamGenerateContent dengan alt\=sse.
Simpan berikut sebagai stream\_response.py dan jalankan python stream\_response.py. Skrip ini menampilkan teks saat tiba, lalu memverifikasi bahwa stream berakhir dengan finish reason normal. Exception membuat teks yang ditampilkan sebagai hasil parsial, bukan jawaban yang diterima.
Baca teks streaming dan wajibkan penyelesaian normal sebelum menerimanya.
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
Untuk [output terstruktur dengan skema](https://ai.google.dev/gemini-api/docs/structured-output), minta application/json dan definisikan field yang diharapkan aplikasi Anda. Contoh ini mengekstrak dua field dari catatan insiden pendek, lalu memeriksa tipenya sebelum mencetak hasil.
Simpan contoh ini sebagai structured\_output.py dan jalankan python structured\_output.py. Contoh ini menggunakan kembali validator respons sebelum mengurai JSON.
Ekstrak field insiden, periksa penyelesaian, dan validasi tipenya.
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))
Anda seharusnya menerima objek yang berisi service dan impact. Kepatuhan skema tidak menetapkan akurasi faktual: bandingkan nilai yang diekstrak dengan input, dan terapkan aturan bisnis sebelum menyimpan atau bertindak berdasarkan hasil.
## Gemini 4 Carbon API Price
Harga perkenalan [Google](https://blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-4-carbon-now-available/) berlaku hingga 30 November 2026; tarif standar mulai berlaku pada 1 Desember. Periksa tarif akun Anda saat ini sebelum menganggarkan permintaan selanjutnya.
Kedua model termasuk dalam keluarga Gemini 4, namun menargetkan beban kerja yang berbeda.
| 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 |
Detail harga tambahan:
* Cached input: $0.10 per satu juta token hingga 30 November, meningkat menjadi $0.20 mulai 1 Desember.
* Batch dan Flex menawarkan pemrosesan berbiaya lebih rendah untuk beban kerja yang dapat menoleransi karakteristik layanan mereka.
* Thinking tokens ditagihkan sebagai output tokens.
* Token yang dikonsumsi oleh instruksi tool internal dan deklarasi fungsi juga dapat ditagihkan.
Google secara eksplisit merekomendasikan Argon untuk sebagian besar rekayasa perangkat lunak dan pekerjaan pengetahuan, menyisihkan Carbon untuk tugas yang menuntut penalaran lebih dalam dan verifikasi diperluas.
Rekomendasi praktis: Pilih Carbon ketika biaya hasil yang salah tinggi atau ketika tugas memerlukan eksplorasi dan verifikasi substansial. Pilih Argon ketika Anda memerlukan penalaran kuat dengan anggaran token yang lebih efisien.
### CometAPI Price
Per 12 November 2026, [jadwal default-group CometAPI](https://www.cometapi.com/models/google/gemini-4-carbon/) mencantumkan $1,60 per juta token input, $8,00 per juta token output termasuk thinking, dan $0,08 per juta token cached-input pada cache hit. Tarif ini 20% di bawah tarif perkenalan Google yang sesuai.
Harga CometAPI dapat berubah seiring perubahan tarif resmi Google. Bandingkan tarif resmi saat ini dengan diskon yang melekat pada akun Anda alih-alih menganggap harga dolar hari ini sebagai permanen. Jika diskon 20% yang sama dipertahankan setelah perubahan tarif, tarif Anda adalah tarif resmi baru × 0,80; konfirmasikan tarif CometAPI yang sebenarnya sebelum menganggarkan. Grup akun lain dapat memiliki diskon berbeda.
Untuk permintaan dengan 100.000 token input tanpa cache dan 10.000 token output, termasuk thinking, biaya token saja adalah $0,24 pada tarif CometAPI yang ditampilkan: $0,16 untuk input plus $0,08 untuk output. Kuantitas yang sama berbiaya $0,30 pada tarif perkenalan Google atau $0,60 pada tarif Desember. Gabungan 110.000 token masuk dalam anggaran bersama model.
Perkiraan ini tidak termasuk tools, retry, dan penyesuaian harga spesifik akun. Biaya output mencakup thinking tokens, sehingga level penalaran yang lebih tinggi dapat meningkatkan tagihan meski jawaban yang terlihat pendek.
### How to Optimize Gemini 4 Carbon API Costs?
Optimalkan untuk biaya hasil yang benar dan dapat digunakan. Permintaan yang lebih murah bernilai buruk jika Anda harus mengulanginya atau memperbaiki jawabannya secara manual.
1. Pilih penalaran dengan sengaja. Mulai dari MEDIUM, uji LOW untuk pekerjaan sederhana, dan gunakan HIGH ketika meningkatkan tingkat penerimaan cukup untuk membenarkan waktu dan token tambahan.
2. Gunakan kembali konteks stabil melalui caching implisit. Alur kerja [Argon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-argon) dan [Carbon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-carbon) Google tidak mendukung pembuatan context-cache eksplisit; mereka mendukung caching implisit. Tempatkan instruksi dan dokumen yang dapat digunakan ulang terlebih dahulu, diikuti pertanyaan yang berubah. Google mendokumentasikan kelayakan untuk prefix bersama minimal 4.096 token. Verifikasi cache hit aktual dan biaya pada rute CometAPI Anda; pengulangan tidak menjamin diskon.
3. Kurangi pekerjaan yang tidak perlu. Kirim halaman atau kutipan yang relevan, minta field output yang Anda perlukan, dan tetapkan anggaran output yang cukup. Thinking dihitung ke penggunaan output, sehingga batas yang terlalu kecil dapat menyebabkan pemotongan dan retry.
4. Ukur seluruh alur kerja. Sertakan penalaran, penggunaan tool, retry, dan jawaban yang ditolak dalam total pengeluaran. Simpan respons valid sehingga kegagalan penyimpanan downstream tidak memicu generasi ulang.
5. Rute berdasarkan nilai yang terbukti. Bandingkan Carbon dan Argon pada tugas identik. Pertimbangkan Batch atau Flex hanya ketika penyedia Anda mendukungnya dan beban kerja dapat menoleransi karakteristik pemrosesan mereka.
Lacak biaya per hasil yang diterima = total pengeluaran alur kerja ÷ hasil yang diterima. Tinjau ini bersama latensi dan kualitas setelah mengubah model, prompt, atau level penalaran.
## Which API Format Should You Use for Gemini 4 Carbon?
Pengembang dapat mengakses [Gemini 4 Carbon API di CometAPI](https://www.cometapi.com/models/google/gemini-4-carbon/) melalui Gemini API asli dan OpenAI-compatible Chat API. Gunakan antarmuka yang cocok dengan format permintaan aplikasi Anda dan persyaratan fitur yang didokumentasikan.
| Interface | Kapan cocok | Pemeriksaan integrasi |
| ----------------------------- | ---------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- |
| Gemini-native GenerateContent | Contoh Python dan REST dalam panduan ini; aplikasi yang sudah menggunakan contents dan generationConfig | Gunakan base URL Gemini dan nama field seperti yang ditunjukkan di atas |
| OpenAI-compatible Chat API | Aplikasi yang sudah diorganisasikan berdasarkan pesan chat | Periksa endpoint, field, dan fitur yang didukung rute Carbon sebelum mengadaptasi kode |
Kompatibilitas berlaku untuk endpoint dan bentuk permintaan tertentu. Jangan kirim field OpenAI Responses ke endpoint asli Gemini, atau mengasumsikan bahwa rute Chat-kompatibel juga mengimplementasikan Responses. Aplikasi yang diaktifkan tool memerlukan round trip terverifikasi dari function call ke hasil yang cocok, bukan hanya prompt teks yang berhasil.
## How to Migrate from Gemini 4 Argon to Gemini 4 Carbon API?
Jika aplikasi Argon Anda sudah menggunakan rute GenerateContent asli CometAPI, mulai dengan mengganti model terkonfigurasi ke **gemini-4-carbon**. Biarkan kunci, base URL, prompt, dan logika validasi tidak berubah untuk perbandingan pertama. Baik [Argon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-argon) maupun [Carbon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-carbon) berbagi banyak konvensi permintaan Gemini 4; pembersihan parameter legacy hanya diperlukan jika field tersebut masih ada di aplikasi Anda.
### 1. Change the model and run a controlled comparison
Dalam penyiapan yang digunakan di panduan ini, ubah COMETAPI\_MODEL dari gemini-4-argon ke gemini-4-carbon, lalu mulai ulang proses Python agar memuat ulang variabel. Gunakan prompt representatif dan tingkat pemikiran yang sama untuk kedua model. Contoh mandiri berikut menggunakan kembali carbon\_client.py dan secara eksplisit memilih 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
Pertahankan LOW, MEDIUM, atau HIGH pada GenerateContent. Hapus thinking\_budget yang tersisa, MINIMAL, atau penggunaan cached\_content eksplisit. Jangan mengandalkan temperature, top\_p, atau top\_k untuk mengontrol hasil. Hapus frequency\_penalty, presence\_penalty, dan candidate\_count di atas 1. Jika Anda memanggil tools, pertahankan ID function-call, nama, dan urutan respons yang cocok. Ini adalah pemeriksaan kompatibilitas, bukan fitur yang baru dihapus dari Argon.
### 3. Validate quality, cost, and latency before rollout
Jalankan set uji yang sama melalui kedua model. Periksa keberhasilan tugas, validasi JSON, eksekusi tool, penyelesaian penuh, token yang ditagihkan, dan waktu yang berlalu. Simpan konfigurasi Argon, rute sebagian kecil trafik ke Carbon, dan perluas hanya jika memenuhi target penerimaan dan anggaran Anda.
### 4. Keep long-output support separate from the model switch
Mulailah dengan permintaan yang selesai dalam satu segmen foreground. Jika Anda memerlukan continuation, terlebih dahulu konfirmasikan bahwa CometAPI mendukung endpoint dan field respons yang diperlukan. Perubahan nama model saja tidak mengaktifkan workflow continuation v1beta1 Google pada gateway v1beta panduan ini. Jagalah output parsial tetap tidak lengkap hingga generasi selesai normal.
## Conclusion
Gunakan permintaan pertama yang berhasil sebagai titik awal untuk uji integrasi. Tambahkan hanya tipe input dan format respons yang diperlukan aplikasi Anda, lalu periksa output lengkap, penanganan error, dan biaya pada tugas yang representatif. Arahkan sebagian kecil trafik melalui integrasi baru sebelum memperluasnya, dan pertahankan konfigurasi yang diketahui berfungsi jika hasil berubah.
## Gemini 4 Carbon FAQ
### How large is Gemini 4 Carbon's context window?
Gemini 4 Carbon mendukung batas konteks input-dan-output terpadu sebesar 1.048.576 token. Anggaran ini mencakup input, penalaran, function calls, dan output yang dihasilkan.
### What are Gemini 4 Carbon's strongest benchmarks?
Hasil unggulan yang dilaporkan mencakup 88,2% pada SEC-bench Pro, 54,8% pada ExploitGym, 71,0% pada CWE-bench, dan 96,2% pada GraphWalks. Hasil ini menyoroti kemampuan keamanan siber, konteks panjang, dan penalaran agenik.
### How does Gemini 4 Carbon compare with Gemini 4 Argon?
Carbon meningkat secara signifikan dibanding Argon pada beberapa benchmark yang dilaporkan, termasuk Artificial Analysis Intelligence Index (59 vs. 50), SWE-sweep (9,6% vs. 4,3%), dan SEC-bench Pro (88,2% vs. 83,4%). Pembedaan utamanya adalah kinerja lebih kuat pada penalaran berkepanjangan dan tugas agenik kompleks.
### Is Gemini 4 Carbon better than Claude Opus 5.5?
Tidak ada model yang memimpin semua benchmark. Carbon mencetak nilai lebih tinggi pada Artificial Analysis Intelligence Index, Terminal-Bench 4.0, GraphWalks, dan evaluasi keamanan siber, sementara Claude Opus 5.5 memimpin OSWorld-2.1 dan FrontierSWE 2 dalam perbandingan yang dipublikasikan Google.
### What thinking levels does Gemini 4 Carbon support?
Gemini 4 Carbon mendukung tingkat LOW, MEDIUM, dan HIGH, dengan MEDIUM sebagai default. Pengembang dapat menggunakan pengaturan ini untuk menyeimbangkan kedalaman penalaran, latensi, dan konsumsi token.
### Can Gemini 4 Carbon process images, audio, and video?
Ya. Model card-nya mencantumkan teks, gambar, audio, dan video sebagai modalitas input yang didukung. Modalitas output yang didokumentasikan adalah teks.
### What is Gemini 4 Carbon's knowledge cutoff?
Model card Google pada November 2026 mencantumkan Maret 2026 sebagai knowledge cutoff. Oleh karena itu, model mungkin tidak mengetahui peristiwa dan perkembangan setelah tanggal tersebut kecuali disuplai melalui tools eksternal atau konteks yang diberikan pengguna.
##
