
The Gemini 4 Carbon API and the Gemini 4 Argon API take the same request and cost the same per input and output token, so choosing between them is a routing decision, not a migration. On PoYo you switch by changing one string: gemini-4-carbon (model page) or gemini-4-argon (model page). This post covers what differs at the API level, what Google's benchmark deltas say about which requests belong on Carbon, and a router you can drop into your code.
New to Carbon? Start with the Gemini 4 Carbon API overview and the first-request guide. For Argon on its own, see the Gemini 4 Argon API guide.
Gemini 4 Carbon API vs Gemini 4 Argon API at a glance
| Gemini 4 Carbon | Gemini 4 Argon | |
|---|---|---|
| PoYo model ID | gemini-4-carbon | gemini-4-argon |
| Endpoints on PoYo | POST /v1/chat/completions, POST /v1beta/models/gemini-4-carbon:generateContent / :streamGenerateContent | Same two formats, with gemini-4-argon |
| Context window | 1M tokens | 1M tokens |
| Max output per response | 64K tokens | Larger: Google describes a 1M unified input-output limit (see our Argon guide) |
| Input types | Text, image, audio, video, PDF | Text, image, audio, video, PDF |
| Google's positioning | Strongest reasoning model; spends more tokens to explore, reason, and verify | Efficient model: faster responses, lower token spend per turn |
| Google's guidance | Hardest multi-step coding, debugging, open-ended research | "The ideal choice for the majority of software engineering and knowledge work" |
The request shape is identical. In Chat Completions the model ID goes in the model field; in Gemini Native it goes in the URL path. Both models support streaming ("stream": true, or :streamGenerateContent). Errors are the same too: 400 for invalid fields or a wrong format, 401 for a bad key, 404 for an unknown model ID, and 402 when your credits run out.
The one limit that forces a route is output size. Carbon's documented ceiling is 64K output tokens per response. If a single response must be longer than that (a full multi-file rewrite in one pass, for example), send it to Argon.
Migration diff: what changes in the JSON
Moving a request from Argon to Carbon in Chat Completions:
{
- "model": "gemini-4-argon",
+ "model": "gemini-4-carbon",
"messages": [
{"role": "user", "content": "Find the root cause of the failing test and propose a patch."}
],
- "max_tokens": 120000,
+ "max_tokens": 64000,
"stream": true
}
In Gemini Native only the path changes:
POST https://api.poyo.ai/v1beta/models/gemini-4-argon:generateContent
POST https://api.poyo.ai/v1beta/models/gemini-4-carbon:generateContent
Cap max_tokens (Chat Completions) or generationConfig.maxOutputTokens (Gemini Native) at 64,000 or less when you call Carbon. Nothing else in the body needs to change.
Price per token: equal, except for cache reads
PoYo prices, from the current model pages (1 credit = $0.005):
| Meter (per 1M tokens) | Gemini 4 Carbon on PoYo | Gemini 4 Argon on PoYo | Google official (both, introductory) |
|---|---|---|---|
| Input | $1.60 (320 credits) | $1.60 (320 credits) | $2.00 |
| Output (incl. thinking) | $8.00 (1,600 credits) | $8.00 (1,600 credits) | $10.00 |
| Cache read | $0.08 (16 credits) | $0.16 (32 credits) | $0.10 (95% off input) |
Google launched Carbon at Argon's introductory price. Its availability post says the introductory period ends on November 30, 2026, and $4 input and $20 output per 1M tokens apply from December 1. The Carbon pricing post compares both Google rates with the current PoYo price.
The difference is the cache-read line: on PoYo, Carbon's cache reads cost half of Argon's. That saving is real but small. It is $0.08 per 1M cached tokens, and 10,000 extra output tokens ($0.08 at $8.00 per 1M) cancel it out. Because Google says Carbon spends more tokens per task than Argon, expect Carbon to cost more per task on most workloads, even with the cheaper cache.
A worked example with identical token counts (400K cached reads, 50K new input, 20K output):
| Carbon | Argon | |
|---|---|---|
| Calculation | 0.4 × $0.08 + 0.05 × $1.60 + 0.02 × $8.00 | 0.4 × $0.16 + 0.05 × $1.60 + 0.02 × $8.00 |
| Cost | $0.272 (54.4 credits) | $0.304 (60.8 credits) |
If Carbon needs 30K output tokens for the same task instead of 20K, it costs $0.352. That's why you should measure cost per completed task, not cost per token. The measuring script is below.
Benchmark deltas as routing evidence
These are Google's own numbers from the Gemini 4 Carbon launch table, so treat them as the vendor's comparison, not an independent test. The delta column tells you where the extra tokens pay off.
| Benchmark | Carbon | Argon | Delta |
|---|---|---|---|
| ExploitGym | 54.8% | 42.0% | +12.8 |
| GraphWalks 256K–1M (BFS F1) | 96.2% | 84.2% | +12.0 |
| AA Intelligence Index v5.0 | 59 | 50 | +9 |
| Agents' Last Exam v1.1 | 77.4% | 69.0% | +8.4 |
| Terminal-Bench 4.0 (AA) | 65.2% | 57.1% | +8.1 |
| OSWorld-2.1 (offline subset) | 81.5% | 74.7% | +6.8 |
| FrontierSWE 2 | 61.2% | 55.0% | +6.2 |
| SWE-sweep | 9.6% | 4.3% | +5.3 |
| SEC-bench Pro | 88.2% | 83.4% | +4.8 |
| RiemannBench | 80.0% | 76.0% | +4.0 |
| CWE-bench | 71.0% | 68.0% | +3.0 |
| AutomationBench (Zapier) | 53.9% | 51.3% | +2.6 |
| Vals Index v2.2 | 70.4% | 69.2% | +1.2 |
Read it as a routing table:
- Big gaps: route to Carbon. Long-context retrieval across 256K–1M tokens, terminal-driven agent work, multi-step agent tasks, and exploit validation.
- Small gaps: keep on Argon. Business automation (+2.6), general knowledge work (Vals Index, +1.2), and patch generation on CWE-bench (+3.0). Here Argon gets most of the score while spending fewer tokens per turn.
- Cyber caveat. Google's cybersecurity results reflect access through its Fairwind Program, and its availability post says Carbon for cyber is offered only through that program. Don't assume the public API reproduces those scores. Test on your own tasks.
Compare scores only within one table. Our Argon guide quotes Google's Argon launch table, which reports Terminal-Bench 4.0 at 57.4% for Argon. The Carbon table uses the Artificial Analysis harness (57.1%).
Routing strategy: default to Argon, escalate to Carbon
Google's guidance and the benchmark gaps point to the same design:
- Default every request to
gemini-4-argon. - Route known-hard task types straight to
gemini-4-carbon: repository-wide debugging, terminal agents, questions over more than 256K tokens of context, and security triage. - Escalate on failure. If Argon's answer fails your check (tests, schema validation, a grader) or stops with
finish_reason: "length", retry once on Carbon. - Force Argon when the response must exceed 64K tokens.
This router uses the OpenAI SDK pointed at PoYo's Chat Completions endpoint. It sends only documented fields: model, messages, and max_tokens.
import os
from openai import OpenAI
client = OpenAI(api_key=os.environ["POYO_API_KEY"], base_url="https://api.poyo.ai/v1")
ARGON, CARBON = "gemini-4-argon", "gemini-4-carbon"
CARBON_MAX_OUTPUT = 64_000
# PoYo USD per 1M tokens, from the model pages on 2026-11-16
PRICE = {ARGON: (1.60, 8.00), CARBON: (1.60, 8.00)}
# Task types where Google's table shows the widest Carbon lead
CARBON_TASKS = {"repo_debug", "terminal_agent", "long_context_qa", "security_triage"}
def pick_model(task_type: str, max_tokens: int) -> str:
if max_tokens > CARBON_MAX_OUTPUT:
return ARGON
return CARBON if task_type in CARBON_TASKS else ARGON
def call(model: str, messages: list, max_tokens: int) -> dict:
resp = client.chat.completions.create(model=model, messages=messages, max_tokens=max_tokens)
u = resp.usage
price_in, price_out = PRICE[model]
cost = u.prompt_tokens / 1e6 * price_in + u.completion_tokens / 1e6 * price_out
return {
"model": resp.model,
"text": resp.choices[0].message.content,
"finish_reason": resp.choices[0].finish_reason,
"prompt_tokens": u.prompt_tokens,
"completion_tokens": u.completion_tokens,
"cost_usd": round(cost, 6),
}
def run(task_type: str, messages: list, check, max_tokens: int = 16_000) -> list:
"""Returns every attempt so you can log cost per task, including escalations."""
first = pick_model(task_type, max_tokens)
attempts = [call(first, messages, max_tokens)]
a = attempts[-1]
failed = a["finish_reason"] == "length" or not check(a["text"])
if first == ARGON and failed and max_tokens <= CARBON_MAX_OUTPUT:
attempts.append(call(CARBON, messages, max_tokens))
return attempts
check is your own acceptance test, for example "the patch applies and the tests pass" or "the JSON parses against my schema". The cost estimate treats every prompt token as uncached input. PoYo's documented usage fields don't break out cached tokens, so this is an upper bound.
Measure cost per task yourself
Per-token prices are equal, so the only number that separates the two APIs is cost per accepted task. Log every attempt from run():
| Field to log | Chat Completions source | Gemini Native source |
|---|---|---|
| Model actually used | model | URL path |
| Input tokens | usage.prompt_tokens | usageMetadata.promptTokenCount |
| Output tokens | usage.completion_tokens | usageMetadata.candidatesTokenCount + thoughtsTokenCount |
| Hit the output cap | finish_reason == "length" | finishReason |
| Passed your check | your grader | your grader |
Google prices output including thinking tokens, so in Gemini Native count thoughtsTokenCount as output. With streaming, the last Chat Completions chunk carries usage. Then, per task type:
cost per accepted task = sum(cost_usd of all attempts, incl. escalations) / tasks that passed
Run a week of real traffic with Argon as the default and compare against a sample sent straight to Carbon. If Carbon passes tasks that Argon needed an escalation for, add that task type to CARBON_TASKS. If Carbon's pass rate on a type matches Argon's, keep that type on Argon. Check your PoYo dashboard against your log for the first few hundred calls.
If you're also weighing models from other vendors, see Gemini 4 Carbon API vs Claude Opus 5.5 API vs GPT-6 Astra API. For an agent loop with budget guards, see Gemini 4 Carbon API for coding agents.
Frequently asked questions
Is the Gemini 4 Carbon API more expensive than the Gemini 4 Argon API?
Not per token. Both cost $1.60 input and $8.00 output per 1M tokens on PoYo, and $2.00 / $10.00 on Google's introductory pricing. On PoYo, Carbon's cache read is cheaper ($0.08 vs $0.16 per 1M). Per task, Carbon usually costs more because Google says it uses more tokens to reason and verify.
How do I switch from the Gemini 4 Argon API to the Gemini 4 Carbon API?
Change "model": "gemini-4-argon" to "model": "gemini-4-carbon" in Chat Completions, or change the model in the Gemini Native URL path. Keep max_tokens at or below 64,000 for Carbon.
What is the max output of the Gemini 4 Carbon API compared with Argon?
Carbon returns up to 64K output tokens per response, with a 1M-token context window. Argon allows much longer single responses, so route outputs over 64K to Argon.
Should I use Gemini 4 Argon or Gemini 4 Carbon for coding?
Google says Argon remains the ideal choice for most software engineering. Use Carbon for the hardest multi-step debugging and terminal-driven agent work, where Google's table shows the largest gaps: Terminal-Bench 4.0 (AA) 65.2% vs 57.1%, and SWE-sweep 9.6% vs 4.3%.
Do Gemini 4 Carbon and Argon use the same API endpoint?
Yes. Both work with POST https://api.poyo.ai/v1/chat/completions (OpenAI-compatible) and POST https://api.poyo.ai/v1beta/models/{model}:generateContent or :streamGenerateContent (Gemini Native), with the same PoYo API key.