Use Gemini 4 Carbon API in CometAPI to add reasoning and document analysis to your application through the Gemini-native GenerateContent interface. Start with a short text request, check that generation finished, and save the answer before adding PDF input, images, streaming, or structured JSON. This guide provides the setup and response-handling code for each step.
Key Takeaways
Model ID: gemini-4-carbon. No free tier — requires paid Gemini API / Cloud Billing.
Unified 1M-token window (input + thinking + output). Default max output ~65K; long decode extends to nearly 1M.
Reviewed for clarity, source attribution and current API terminology.
low
medium
high
Introductory price until Nov 30, 2026: $2 / $10 per 1M tokens (cached input $0.10). Doubles on Dec 1.
Excellent for long-horizon agentic coding, scientific reasoning, knowledge work, and cybersecurity tasks.
Official SDKs (google-genai) + OpenAI-compatible endpoints available.
CometAPI offers the easiest production access with a single key, competitive rates, and seamless switching between Gemini 4 Carbon, Claude, and 500+ other models.
Gemini 4 Carbon launch artwork. Image: Google. Original artwork.
What Is Gemini 4 Carbon API?
Gemini 4 Carbon is Google's frontier reasoning model for long-horizon agentic workflows, complex software engineering, cybersecurity, and scientific research. Built on Gemini 4 Argon, it uses deeper reasoning and extended verification loops to tackle multi-step tasks that require sustained problem-solving rather than a single response. Compared with Argon, Carbon is designed for more demanding workloads where accuracy and task completion matter more than minimizing token usage. Google announced paid developer access on November 10, 2026. Its multimodal input support lets you combine text with visual and other media inputs; the generated output is text. CometAPI offers discounted API access.
For an API integration, begin with one task whose result you can check: summarize a document, extract fields from an incident note, or review a screenshot. A broader agent workflow can build on that working request once you have verified the route’s supported tools and response behavior.
Other Ways to Use It
Google AI Studio Playground: Select the model and test prompts interactively (requires paid access for Carbon).
Gemini app / AI Mode / Antigravity: Available if you have Google AI Ultra (select the model where offered).
Enterprise / Cloud: Use via Gemini Enterprise Agent Platform or Vertex-style endpoints with the same model ID (project + location setup).
Scientists/researchers can apply for limited free access in some cases.
What Are the Gemini 4 Carbon API Specifications ?
The official model specifications distinguish the shared context budget from the output limit of each foreground segment. These are model-level limits; your gateway may also apply request-size and feature restrictions.
Limitations and API Considerations
Before expanding your integration, check how Carbon handles context, generation settings, caching, and access. The table pairs each constraint with a practical action so you can avoid invalid requests, incomplete results, and unexpected costs.
Google’s Carbon developer guide documents the API rules; its model card describes reliability and specialized-access limitations. Confirm the corresponding features on your CometAPI route before enabling them in production.
Thinking Levels: How to Choose the Right Setting
Start with MEDIUM, then adjust the level to the task and the quality you need.
LOW: Use it for simple extraction, classification, and summaries when response time and cost are priorities. Try it for tasks such as labeling support tickets, and check that it still meets your accuracy target.
MEDIUM: Use this default starting point for everyday coding, document analysis, and routine reasoning. It is a practical baseline for evaluating whether a different level improves your application.
HIGH: Use it for complex debugging, multi-step research, and scientific reasoning that benefit from deeper investigation. Allow for additional reasoning tokens, and keep it only when the quality gain justifies the added cost and time.
Higher thinking levels do not automatically guarantee better results for every task. Benchmark your own workloads and compare task completion quality, latency, and total token usage before changing production defaults.
How Does Gemini 4 Carbon Perform on AI Benchmarks?
Selected Benchmark Results
The Artificial Analysis Carbon (High) and Argon (High) pages show the following snapshot, checked on November 12, 2026. These are benchmark results, not measurements of CometAPI latency.
The output-token totals cover the evaluation, not one request. Task cost uses Artificial Analysis’s pricing assumptions rather than CometAPI’s current discount. Carbon waits longer before its first answer token, yet completes the benchmark task faster and at lower reported cost; token volume alone does not determine value.
Use Carbon when its deeper verification improves difficult code review, research, or other costly-to-get-wrong work. Test Argon for routine coding and knowledge tasks, but confirm savings on your own workload. Run identical prompts and compare total spend divided by accepted results, alongside completion time and failure rate.
How Do You start with the Gemini 4 Carbon API in CometAPI?
You will need a CometAPI account with access to the model and sufficient credit, a Python environment, and basic familiarity with running scripts. Use a project directory for the files below so each example can import the same client configuration.
Why Use Gemini 4 Carbon API Through CometAPI?
CometAPI is useful when you want to evaluate Carbon alongside other models while managing access and billing through one provider. Its Carbon route offers both Gemini-native GenerateContent and an OpenAI-compatible Chat interface, so you can choose the request format that fits your application.
For this guide, the native route lets you reuse the Google Gen AI SDK with a CometAPI key and base URL. Current default-group prices are 20% below Google’s introductory rates. Keep your model ID in configuration so you can compare Carbon and Argon without rewriting your application, and check route-specific support before adding tools, file uploads, or long continuations.
Step 1: Create Your Account and Set Your API Key
Sign in to CometAPI, create or open your API key, and store it as an environment variable. Avoid putting keys directly in source code or committing them to a repository.
Use the command for your shell. Set the variables in the same terminal you will use to run Python; replace the key placeholder with your own key.
Step 2: Install the SDK and Configure the Endpoint
Install the SDK in your project environment. Using python -m pip keeps the installer tied to the interpreter that will run the example.
Install or update the Google Gen AI SDK.
python -m pip install --upgrade google-genai
CometAPI documents a Gemini-native endpoint with a custom SDK base URL. Use your CometAPI key for this endpoint. The settings below apply to GenerateContent requests.
Step 3: Create a Reusable Client and Validate Responses
Save this setup as carbon_client.py. It defines the client once and provides completed_text for the text-only responses used in this guide. The helper checks the candidate finish reason before returning answer text, so an empty or truncated result is not silently treated as success.
Create carbon_client.py with the CometAPI client and a text-response validator.
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
Create first_request.py beside carbon_client.py and add the code below. It sends a short checklist prompt using MEDIUM thinking and a 4,096-token output budget, checks completion with completed_text(response), and saves the answer to answer.txt as UTF-8. Run python first_request.py from your project directory, then open answer.txt and confirm that all five review points are relevant and usable. Check the printed usage metadata for token consumption, including thinking; a normal finish does not establish answer quality. If the request fails or returns incomplete output, use the troubleshooting section to check credentials, error details, and the finish reason before retrying.
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?
Run these examples from the same directory as carbon\_client.py. They load local files into inline content parts, keeping the initial workflow independent of a separate file-upload service.
PDF understanding includes visual content: Gemini can interpret text, tables, charts, and images together. [Google’s document-processing guide](https://ai.google.dev/gemini-api/docs/document-processing) describes support for PDFs up to 1,000 pages, subject to file-size and context limits. Page count is a ceiling, not a guarantee that every document will fit a gateway request.
Use inline input for small, temporary PDFs. For larger files or repeated multi-turn questions, Google recommends the Files API to avoid resending the full file. Before using that workflow through CometAPI, verify its upload endpoint and file-reference support; the inline example below remains a practical starting point.
### Summarize a local PDF
Google documents [inline PDF input](https://ai.google.dev/gemini-api/docs/document-processing) for GenerateContent. Place a small, non-sensitive report.pdf in the project directory, then save the following as analyze\_pdf.py and run python analyze\_pdf.py.
Send a local PDF and save its completed summary.
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),
)
Check the summary against the file before expanding to larger documents. Request-size limits and file-reference support depend on the gateway. Google’s support for Office formats or Cloud Storage references does not by itself establish support for those inputs through your CometAPI route.
### Review a local screenshot
For [inline image input](https://ai.google.dev/gemini-api/docs/image-understanding), match the MIME type to the file. Place a PNG screenshot named screen.png beside the script. Save this example as analyze\_image.py and run python analyze\_image.py to review visible text and layout.
Analyze a PNG screenshot without relying on a public image 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))
Compare each reported issue with the screenshot. If you send a JPEG instead, change both the filename and MIME type to match; changing the extension alone does not convert the image.
## How Do You Stream Gemini 4 Carbon Responses ?
### Display streamed text and check completion
Streaming returns response chunks as server-sent events (SSE), allowing an application to display partial output while generation continues.
The SDK exposes [streaming text generation](https://ai.google.dev/gemini-api/docs/text-generation) through generate\_content\_stream. For direct HTTP requests, CometAPI uses streamGenerateContent with alt\=sse.
Save the following as stream\_response.py and run python stream\_response.py. It displays text as it arrives, then verifies that the stream ended with a normal finish reason. An exception leaves the displayed text as a partial result, not an accepted answer.
Read streaming text and require a normal finish before accepting it.
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
For [schema-constrained output](https://ai.google.dev/gemini-api/docs/structured-output), request application/json and define the fields your application expects. This example extracts two fields from a short incident note, then checks their types before printing the result.
Save this example as structured\_output.py and run python structured\_output.py. It reuses the response validator before parsing the JSON.
Extract incident fields, check completion, and validate their 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))
You should receive an object containing service and impact. Schema compliance does not establish factual accuracy: compare extracted values with the input, and apply any business rules before storing or acting on the result.
## Gemini 4 Carbon API Price
Google’s [introductory pricing](https://blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-4-carbon-now-available/) runs through November 30, 2026; its standard rates take effect on December 1. Check your account’s current rates before budgeting later requests.
Both models belong to the Gemini 4 family, but they target different 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 |
Additional pricing details:
* Cached input: $0.10 per million tokens through November 30, increasing to $0.20 from December 1.
* Batch and Flex offer lower-cost processing for workloads that can tolerate their service characteristics.
* Thinking tokens are billed as output tokens.
* Tokens consumed by internal tool instructions and function declarations can also be billable.
Google explicitly recommends Argon for most software engineering and knowledge work, reserving Carbon for tasks that demand deeper reasoning and extended verification.
Practical recommendation: Choose Carbon when the cost of an incorrect result is high or when a task requires substantial exploration and verification. Choose Argon when you need strong reasoning at a more efficient token budget.
### CometAPI Price
As checked on November 12, 2026, [CometAPI’s default-group schedule](https://www.cometapi.com/models/google/gemini-4-carbon/) lists $1.60 per million input tokens, $8.00 per million output tokens including thinking, and $0.08 per million cached-input tokens on cache hits. These rates are 20% below Google’s corresponding introductory rates.
CometAPI pricing can change as Google’s official rates change. Compare the current official rate with the discount attached to your account rather than treating today’s dollar price as permanent. If the same 20% discount is maintained after a rate change, your rate is the new official rate × 0.80; confirm the actual CometAPI rate before budgeting. Other account groups can have different discounts.
For a request with 100,000 uncached input tokens and 10,000 output tokens, including thinking, the token-only cost is $0.24 at the displayed CometAPI rate: $0.16 for input plus $0.08 for output. The same quantities cost $0.30 at Google’s introductory rates or $0.60 at its December rates. The combined 110,000 tokens fit within the model’s shared budget.
This estimate excludes tools, retries, and any account-specific pricing adjustments. Output cost includes thinking tokens, so a higher reasoning level can increase the bill even if the visible answer is short.
### How to Optimize Gemini 4 Carbon API Costs?
Optimize for the cost of a correct, usable result. A cheaper request is poor value if you must repeat it or manually repair the answer.
1. **Choose reasoning deliberately.** Start at MEDIUM, test LOW for simple work, and use HIGH when it improves acceptance enough to justify the added time and tokens.
2. **Reuse stable context through implicit caching.** Google’s [Argon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-argon) and [Carbon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-carbon) workflows do not support explicit context-cache creation; they support implicit caching. Place reusable instructions and documents first, followed by the changing question. Google documents eligibility for shared prefixes of at least 4,096 tokens. Verify actual cache hits and charges on your CometAPI route; repetition does not guarantee a discount.
3. **Reduce unnecessary work.** Send relevant pages or excerpts, request the output fields you need, and set a sufficient output budget. Thinking counts toward output usage, so an overly small cap can cause truncation and retries.
4. **Measure the entire workflow.** Include reasoning, tool use, retries, and rejected answers in total spend. Save valid responses so downstream storage failures do not trigger another generation.
5. **Route by demonstrated value.** Compare Carbon and Argon on identical tasks. Consider Batch or Flex only when your provider supports them and the workload can tolerate their processing characteristics.
Track cost per accepted result \= total workflow spend ÷ accepted results. Review this together with latency and quality after changing a model, prompt, or reasoning level.
## Which API Format Should You Use for Gemini 4 Carbon?
Developers can access [Gemini 4 Carbon API in CometAPI](https://www.cometapi.com/models/google/gemini-4-carbon/) through the native Gemini API and an OpenAI-compatible Chat API. Use the interface that matches your application’s request format and documented feature requirements.
| Interface | When it fits | Integration check |
| ----------------------------- | ---------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- |
| Gemini-native GenerateContent | The Python and REST examples in this guide; applications already using contents and generationConfig | Use the Gemini base URL and field names shown above |
| OpenAI-compatible Chat API | An existing application organized around chat messages | Check the Carbon route’s documented endpoint, fields, and supported features before adapting code |
Compatibility applies to a particular endpoint and request shape. Do not send OpenAI Responses fields to the Gemini-native endpoint, or assume that a Chat-compatible route also implements Responses. A tool-enabled application needs a verified round trip from a function call to its matching result, not just a successful text prompt.
## How to Migrate from Gemini 4 Argon to Gemini 4 Carbon API?
If your Argon application already uses CometAPI’s Gemini-native GenerateContent route, start by switching the configured model to **gemini-4-carbon**. Keep the key, base URL, prompt, and validation logic unchanged for the first comparison. Both [Argon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-argon) and [Carbon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-carbon) share many Gemini 4 request conventions; legacy-parameter cleanup is only needed if those fields remain in your application.
### 1. Change the model and run a controlled comparison
In the setup used in this guide, change COMETAPI\_MODEL from gemini-4-argon to gemini-4-carbon, then restart the Python process so it reloads the variable. Use the same representative prompt and thinking level for both models. The following standalone example reuses carbon\_client.py and explicitly selects 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
Keep LOW, MEDIUM, or HIGH on GenerateContent. Remove any leftover thinking\_budget, MINIMAL, or explicit cached\_content usage. Do not rely on temperature, top\_p, or top\_k to control the result. Remove frequency\_penalty, presence\_penalty, and candidate\_count values above 1. If you call tools, preserve matching function-call IDs, names, and response order. These are compatibility checks, not features newly removed from Argon.
### 3. Validate quality, cost, and latency before rollout
Run the same test set through both models. Check task success, JSON validation, tool execution, full completion, billed tokens, and elapsed time. Keep the Argon configuration available, route a small portion of traffic to Carbon, and expand only if it meets your acceptance and budget targets.
### 4. Keep long-output support separate from the model switch
Begin with requests that finish in one foreground segment. If you need continuation, first confirm that CometAPI supports the required endpoint and response fields. A model-name change alone does not enable Google’s v1beta1 continuation workflow on this guide’s v1beta gateway. Keep partial output incomplete until generation finishes normally.
## Conclusion
Use the first successful request as the starting point for an integration test. Add only the input types and response formats your application needs, then check complete outputs, error handling, and cost on representative tasks. Route a small share of traffic through the new integration before expanding it, and keep a known working configuration available if results change.
## Gemini 4 Carbon FAQ
### How large is Gemini 4 Carbon's context window?
Gemini 4 Carbon supports a unified input-and-output context limit of 1,048,576 tokens. This budget includes input, reasoning, function calls, and generated output.
### What are Gemini 4 Carbon's strongest benchmarks?
Its standout reported results include 88.2% on SEC-bench Pro, 54.8% on ExploitGym, 71.0% on CWE-bench, and 96.2% on GraphWalks. These results highlight its cybersecurity, long-context, and agentic reasoning capabilities.
### How does Gemini 4 Carbon compare with Gemini 4 Argon?
Carbon improves substantially over Argon on several reported benchmarks, including Artificial Analysis Intelligence Index (59 vs. 50), SWE-sweep (9.6% vs. 4.3%), and SEC-bench Pro (88.2% vs. 83.4%). Its primary distinction is stronger performance on extended reasoning and complex agentic tasks.
### Is Gemini 4 Carbon better than Claude Opus 5.5?
Neither model leads every benchmark. Carbon scores higher on Artificial Analysis Intelligence Index, Terminal-Bench 4.0, GraphWalks, and cybersecurity evaluations, while Claude Opus 5.5 leads OSWorld-2.1 and FrontierSWE 2 in Google's published comparison.
### What thinking levels does Gemini 4 Carbon support?
Gemini 4 Carbon supports LOW, MEDIUM, and HIGH thinking levels, with MEDIUM as the default. Developers can use these settings to balance reasoning depth, latency, and token consumption.
### Can Gemini 4 Carbon process images, audio, and video?
Yes. Its model card lists text, images, audio, and video as supported input modalities. Its documented output modality is text.
### What is Gemini 4 Carbon's knowledge cutoff?
Google's November 2026 model card lists March 2026 as its knowledge cutoff. The model may therefore lack knowledge of events and developments after that date unless they are supplied through external tools or user-provided context.
##
Area
Limitation or requirement
Developer implication
Unified token budget
Input and output share 1,048,576 tokens, including thinking and function calls.
Reserve output space before adding conversation history or files.
Long decoding
A foreground segment allows up to 65,536 output tokens when streaming, or 32,768 without streaming;
longer generation needs continuation.
Thinking levels
Low, Medium, High; Medium is default
For GenerateContent, send LOW, MEDIUM, or HIGH; MINIMAL is rejected.
Thinking budget
Legacy thinking_budget parameter is rejected
Remove thinking_budget from request builders and use thinking_config.thinking_level in Python, or thinkingConfig.thinkingLevel in REST JSON.
Sampling
Custom temperature, top_p, and top_k values are ignored
Use thinking_level to select reasoning depth and response_schema for structured output.
Context caching
Implicit caching is supported; explicit context-cache creation is not.
Put reusable context first and the changing question last. Remove explicit cache-creation calls and cached_content references
API cost
Thinking tokens are billed as output
Count thinking as well as visible output.
Cybersecurity access
Specialized cyber access is restricted
Check eligibility for specialized Fairwind access. Standard Carbon access does not by itself grant access to the cyber-permissive variant.
Reliability
Hallucinations, occasional timeouts, and higher token usage can occur
Validate facts, code, and extracted fields.
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%
Metric
Carbon (High)
Argon (High)
Intelligence Index
60
50
Output speed
80 tokens/s
65 tokens/s
Time to first answer token
67.83 s
37.64 s
Time per Intelligence Index task
25.5 min
30.0 min
Output tokens across the evaluation
205M
113M
Cost per Intelligence Index task
$7.76
$9.95
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
RiemannBench
80.00%
76.00%
72.00%
69.60%
How to Use Gemini 4 Carbon API? A Complete Developer Guide - CometAPI
