Gemini 4 Carbon: Release Date, Pricing, API Model ID and How to Use It

Short answer

Gemini 4 Carbon (API model ID gemini-4-carbon) is Google’s strongest model, built on Gemini 4 Argon and tuned to think longer, verify more and run for hours on hard coding, science and security work. It has been generally available since November 10, 2026 on the paid Gemini API (Google AI Studio, Android Studio and Gemini for business) and, for Google AI Ultra subscribers, in Google Antigravity, the Gemini app and AI Mode in Search. The price is $2 per million input tokens and $10 per million output tokens through November 30, 2026, then $4 and $20 from December 1. Cached input is $0.10 per million, then $0.20. It is not on the free tier.

Three things keep the headline simple. First, Google itself says Argon remains the ideal choice for most software engineering and knowledge work, and that Carbon is for tasks that test the limits of a model’s intelligence. Second, Carbon is not the top model on the broad independent index: as of November 11, 2026, Artificial Analysis lists Claude Fable 5.2 (max) at 65 and Carbon (high) at 60, though Carbon wins some individual boards such as Terminal-Bench 4.0 and the Cursor board. Third, the cheapest-looking token price does not guarantee the cheapest finished task, because Carbon spends many thinking tokens. We did not run hands-on tests; every figure below is from the cited source and labelled as vendor-reported, independent or press.

This guide is part of a three-post cluster. For the Anthropic side, read our Claude Fable 5.2 complete guide; for the decision table, read Gemini 4 Carbon vs Claude Fable 5.2.

Video: Gemini 4 Carbon vs Claude Fable 5.2: The Internet Tested Both (Who Actually Wins?), a creator roundup. We use it only as commentary. Its headline numbers (Fable 5.2 at 65 versus Carbon at 60 on the Artificial Analysis index, and Carbon 60.4% versus Fable 60.0% on CursorBench) match the Artificial Analysis and Cursor pages we checked below.

Launch posts and timeline

Google’s own accounts carry the main launch messages. These are the five posts we could verify with their numeric status IDs, from Google DeepMind, Google AI, Demis Hassabis and Cursor.

Carbon vs Argon: when Argon is enough

Carbon is not a separate architecture. The DeepMind model card says plainly that Gemini 4 Carbon is based on Gemini 4 Argon and points to the Argon card for architecture, training data and hardware. The two share the same unified 1M-token window, built-in tools and per-token price. The difference, according to Google’s developer docs, is how many thinking tokens each spends per turn. Carbon explores hypotheses longer, checks edge cases and runs more verification loops, which raises token use and latency compared with Argon.

Google’s guidance is consistent across the launch post, the Verge’s summary of it and the API docs. Argon is the default for interactive coding, day-to-day feature work and fast production loops. Carbon is for complex root-cause debugging, architectural design, dense multimodal synthesis, scientific proofs and security auditing. Our Gemini 4 Argon complete guide covers the base model.

A practical rule

Start every workload on Argon. Move a task to Carbon only if your own evals show a pass-rate or review-quality gain that survives the extra cost and wait. Because both models share a request schema, the switch is a one-string change, and Google’s migration notes confirm no request changes are needed when moving from Argon to Carbon.

Where the gap shows in Google’s own table

In the vendor-reported model card, Carbon leads Argon on every row listed: for example Terminal-Bench 4.0 at 65.2% versus 57.1%, GraphWalks long-context BFS at 96.2% versus 84.2%, and Terminal-Bench-Science 0.1 at 64.8% versus 52.9%. The Artificial Analysis index shows a smaller practical edge, 60 for Carbon (high) versus 50 for Argon (high) on the same leaderboard, at the same per-token list price. The cost per task is the counterweight, covered below.

Specs and model ID

The exact Gemini API model ID is gemini-4-carbon. Google’s docs list it as the model code on the model page, and the same string appears in the AI Studio deep link, the Latest Gemini models page and the pricing page. The ai.google.dev copies of those pages did not render for our fetcher, so we read the same documentation at its aistudio.google.com URLs. We did not find a separate dated or preview alias for the public model.

How to access Carbon

Carbon is spread across several surfaces, and the plan or tier you need differs by surface. The Google GA post and the model card list the channels; the summary below keeps each tied to its condition.

Gemini API and Google AI Studio (paid tier)

All paying developers can call gemini-4-carbon on the paid Gemini API tier through Google AI Studio and Android Studio. There is no free-tier access. Google’s GA post also says Google AI Ultra subscribers can try it in Google Antigravity and AI Studio.

Gemini for business and CodeMender

Enterprises can use Carbon through the Gemini for business API or model drop-down, Google Antigravity, or CodeMender. VentureBeat notes the rollout materials leave Vertex AI availability, regions and support commitments unspecified, which matters if you buy through a particular cloud contract.

Google Antigravity, the Gemini app and AI Mode

Google AI Ultra subscribers get Carbon in the Antigravity App, the Antigravity CLI and IDE extensions, the Gemini app and AI Mode in Search. VentureBeat reports US prices of $99.99 a month for Ultra 5x and $199.99 a month for Ultra 20x. The Verge notes it is unclear when or whether lower tiers or free users will get Carbon.

Scientists and the Fairwind Program

Scientists can apply for Antigravity’s highest usage tier free for six months, now covering both Argon and Carbon, on a rolling basis subject to eligibility, capacity and selection. Verified cybersecurity defenders can apply to the Fairwind Program for Carbon for cyber, a separate access path with the specialized capabilities behind Google’s headline cyber results.

Other tools

Cursor announced Carbon support on November 10, 2026 (post embedded above). Check each tool’s own pricing, since Cursor and similar apps set their own rates and effort labels.

Pricing, caching and the December jump

The Gemini API pricing page gives one standard rate for Carbon, the same as Argon. The introductory period ends November 30, 2026, and Google’s fine print says the prices apply to the public Carbon model only. The pricing page also states that thinking tokens are billed as output and that every token the model processes is counted, including internal tool system instructions and function declarations when using grounding.

Worked examples (our arithmetic, same token counts)

A request with 200K uncached input tokens and 30K output tokens (thinking included) costs 0.2 x $2 + 0.03 x $10 = $0.70 at introductory prices and $1.40 from December 1. If 150K of that input is an implicit cache hit, the introductory cost falls to $0.015 + $0.10 + $0.30 = $0.415, and the December cost to $0.03 + $0.20 + $0.60 = $0.83. A long-decode run capped at 262,144 output tokens costs at most about $2.62 in output at introductory prices and $5.24 in December, before input. Compare that with Claude Fable 5.2 at $8 and $40 for the same tokens: $2.80 for the first example. Token counts will not be equal across vendors, so treat this as a ceiling check, not a forecast.

Cost per task is not cost per token

Artificial Analysis reports $7.76 per Intelligence Index task for Carbon (high) at standard prices, and $6.59 for medium, and notes Carbon is very verbose with 205M output tokens used on the index. In its October 28 write-up, Artificial Analysis called that cost per task in line with Argon’s $7.68 at the time, with a score nine points higher; its current leaderboard lists Argon (high) at $9.95. Artificial Analysis charts use standard pricing, so during the introductory period your real bill per task would be roughly half the charted figure if token counts hold. VentureBeat’s estimate that Carbon is one quarter of Fable 5.2’s per-token rate through November 30 and half afterward follows directly from the list prices.

Benchmarks, labelled by source

Benchmarks come from three kinds of source here: Google’s own tables (vendor-reported), independent boards (Artificial Analysis, Cursor) and press that reviewed them. Scores are dated November 11, 2026 unless stated. Google’s model card results are stated as of October 2026 and compare Carbon with Argon, GPT-6 Astra, Claude Opus 5.5 and Claude Fable 5.1, not Fable 5.2.

Vendor-reported (Google model card)

The same table shows Carbon behind rivals on several rows, which is worth noting because vendors rarely lose in their own charts: Opus 5.5 leads OSWorld-2.1 and Astra leads FrontierSWE 2. The Verge adds the standard caution that companies can and do cherry-pick benchmark results.

Independent: Artificial Analysis (as of Nov 11, 2026)

Carbon’s index score changed after launch. Artificial Analysis first published 59 on October 28, 2026 and lists 60 for Carbon (high) on its model page and leaderboard as of November 11; we did not find its explanation for the one-point change. At announcement it called Carbon the new number one; the Fable 5.2 launch on November 9 moved it to fourth in the rankings, behind three Fable 5.2 configurations. On the October 28 article, Carbon also scored 54 on AA-Omniscience v1.1 with an 11% hallucination rate (accuracy 58%), and with the Antigravity CLI scored 59 on the Coding Agent Index, three points behind Claude Code with Opus 5.5 at 62. Those are October figures and may have moved with the regrade.

Cursor, Zapier and the press layer

Cursor posted that Carbon at high effort tops CursorBench at 60.4%. VentureBeat’s review of Cursor’s public table shows Fable 5.2 (max) at 60.0% and $32.79 per task with no Carbon row in the version it saw, and notes that Google’s claim of first place at less than half the cost on CursorBench 4.0 and Perplexity’s WANDR omits the underlying numbers. Zapier’s AutomationBench, per VentureBeat, has Carbon (high) at 53.88% and about $2.12 per task versus Fable 5.2 (max) at 51.45% and $4.64. In Artificial Analysis’s head-to-head tests quoted by the same article, Carbon (high) reaches 65.2% on Terminal-Bench 4.0 versus 61.6% for Fable’s best run, while Fable leads FrontierCode 2.0 at 49.1% versus 40.6% and Terminal-Bench-Science at 74.6% versus 64.8%. Ridge’s note on the same day reaches a similar split: Fable on the broad boards, Carbon on CursorBench.

Cyber results (Google, Fairwind access)

Google reports Carbon at 88.2% on SEC-bench Pro (finding vulnerabilities), 54.8% on ExploitGym (exploitation) and 71.0% on Collinear’s CWE-bench (patching), all evaluated without guardrails and, per the model card, reflecting access through Fairwind. The model card’s comparison shows Argon at 83.4%, 42.0% and 68.0% on those rows. All of these are vendor-reported, and we found no independent public cyber score for Carbon.

/swarm in Google Antigravity

The GA post pairs Carbon with a preview of /swarm, which Google’s docs describe as a command that runs a team of named agents that split your task, work in parallel and coordinate on one shared message board.

How a swarm runs

Your current conversation becomes the coordinator. It splits the task into pieces that do not collide, names a worker for each (for example @parser or @api-tests) and posts each worker’s public brief on the board. A verifier, usually one per two to four workers, reads diffs, runs tests and reports problems to the author. Workers do not message each other privately, so the whole conversation stays on the board. Idle members sleep without using tokens and wake when mentioned, and a monitor wakes only if everyone goes quiet before the work is done. The Antigravity blog says workers run in isolated git worktrees so edits never collide, while the docs say workers share your workspace by default and the coordinator can give each its own working copy when several edit at once.

Where Carbon fits

Workers use the same model as your conversation unless you say otherwise, and agents can be pinned to different models. Google’s suggestion is to put Carbon on high-leverage roles such as the coordinator, architecture, security auditing and adversarial verification, and let lighter, faster models do parallel file edits. The docs show an example prompt that runs the verifier on a different model than the workers.

/swarm Migrate the three API handlers in src/routes to the new validation layer. Give each handler its own worker, add tests next to each, pin the verifier to Gemini 4 Carbon, and have it run npm test and review every diff.

Availability, quota and sibling modes

The swarm docs list /swarm on Google AI Pro and Google AI Ultra plans across the Antigravity App and CLI, while Carbon itself is for Ultra subscribers in Antigravity. Both pages warn that a swarm uses quota much faster than a single conversation, since every worker is its own agent. Antigravity also offers subagents (single side tasks), /boost (hard problems that need deep reasoning) and /teamwork (repository-scale, multi-day projects with audit gates). The docs’ rule of thumb for /swarm is a large task that divides cleanly across files, packages or questions. Press the CLI’s live board with /swarm board or Alt+S.

Google’s showcase builds, such as the Three.js reconstruction of its Platform 37 office across 10 overnight loops, are vendor demonstrations. They show intent and scale but are not a benchmark.

API quickstart

Carbon uses the Interactions API in the current Google GenAI SDK. The Python quickstart below follows the Google docs, with the recommended default thinking level and the 64K output cap. The curl example is adapted from the Argon docs page with the model string swapped, since Google’s migration notes say no request schema changes are needed; test it on your key before relying on it.

Python

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-4-carbon",
    input="Analyze this payment pipeline for race conditions during retries and rewrite the transaction locks safely.",
    generation_config={
        "thinking_level": "medium",  # low | medium (default) | high
    },
)

print(interaction.output_text)

curl (adapted from the Argon docs)

curl "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -X POST \
  -d '{
    "model": "gemini-4-carbon",
    "input": "Write a three.js script that renders a realistic 3D black hole with gravitational lensing."
  }'

Thinking levels

thinking_level is the main control over quality, latency and spend. low uses the fewest tokens and suits simpler or cost-sensitive work, with possible quality drops on hard tasks. medium is the default and Google’s recommendation for most tasks including complex code and agents. high uses the most tokens and has the slowest first token, for hard math, science and the most difficult agent tasks. Google’s advice is to run evals at all three and pick the lowest level that meets your bar. The Artificial Analysis table above shows why: Carbon (low) first-answer time is 12.9 seconds versus 67 seconds at high.

Long decode and background execution

Synchronous responses stop at 65,536 tokens, and max_output_tokens caps thinking plus output together. To go past 64K, set background=True and raise max_output_tokens above 65,536, up to 1,048,576 minus your input. Google’s servers run continuation hops of up to 64K each and each adds a model_output step, so join all of them. If you set background without max_output_tokens, the server stops after 64K. Google suggests 131,072 or 262,144 for complex reasoning and coding.

import time
from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-4-carbon",
    input="Write a complete, rigorous proof of the prime number theorem.",
    background=True,
    generation_config={
        "max_output_tokens": 262144,
        "thinking_level": "high",
    },
)

while interaction.status in ("in_progress", "queued"):
    time.sleep(5)
    interaction = client.interactions.get(id=interaction.id)

# Each continuation hop adds a model_output step, so join them all.
text = "".join(
    content.text
    for step in interaction.steps
    if step.type == "model_output"
    for content in step.content
    if content.type == "text"
)
print(text)

Antigravity agent in Gemini Managed Agents

The Antigravity agent in Gemini Managed Agents supports Carbon through the API. Set the model in agent_config:

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    agent="antigravity-preview-09-2026",
    input="Audit https://web.dev for performance, Core Web Vitals and SEO, and format a prioritized scorecard.",
    environment="remote",
    agent_config={
        "type": "antigravity",
        "model": "gemini-4-carbon",
    },
)

print(interaction.output_text)

Migration checklist

From Gemini 4 Argon

Change the model string from gemini-4-argon to gemini-4-carbon. Keep thinking_level at medium unless a workload needs high, and make sure max_output_tokens and timeouts allow longer reasoning passes. Keep Argon where speed and token spend matter, such as interactive coding and fast production loops.

From Gemini 3 and earlier

Google’s checklist for older models is longer. Review these in order:

• Raise max_output_tokens to at least 32,768 if you set it explicitly, since Carbon can spend more of the limit on thinking.
• Choose a thinking level and test at low, medium and high.
• Remove explicit caching (cachedContents, caches.create). Implicit caching applies to prompts of at least 4,096 tokens and discounts cache hits by 95%.
• Remove temperature, top_p and top_k. If provided they are ignored.
• Use background execution for outputs over 64K tokens.
• Increase client timeouts to at least 15 minutes, because hard prompts can take several minutes.
• Keep conversation state on the server with previous_interaction_id for multi-turn and function-calling conversations.
• Re-estimate costs, because every token is billed, including tool instructions and function declarations under grounding.

Safety claims

Google’s posts make several safety claims. All are vendor-reported and drawn from Google’s own evaluations, so read them as claims to check, not independent findings.

• Prompt injection: 0.0% attack success on the Gray Swan indirect prompt injection benchmark, versus 0.7% for Argon. Google also says injection robustness remains an area for improvement and that its own red teaming found sophisticated attacks that still succeed in some distributions.
• Misuse safeguards: in simulated cyberattack environments, safeguards blocked 99% of attack trajectories, with a per-attempt breach rate of 0.8% versus 3.1% on Argon. Gray Swan’s automated cyberattack success rate fell to 2.17% from 9.86%. Trajectory Labs found no new universal jailbreaks in 132 hours and over 13,000 requests.
• Honesty and shortcuts: 92% on a 375-task agentic honesty benchmark versus 70% for Argon; successful cheating on Terminal-Bench 4.0 reduced to 0.0% with attempts at 0.4%; high-severity misalignment alerts in internal live coding down nearly 80%.

The model card’s automated safety table shows Carbon ahead of Argon on text and multilingual safety, slightly behind on image-to-text (minus 1.00 percentage point), and similar on refusals and tone. Google also says it is engaged in the US government’s voluntary pre-release testing process. Read the full Safety and Security report linked from the model card before putting Carbon in front of users.

Carbon against Fable 5.2, Opus 5.5 and Astra

The decision depends on the job. On the broad Artificial Analysis index, Fable 5.2 leads and Carbon sits behind its top three configurations but ahead of Opus 5.5 (max, 59) and GPT-6 Astra (max, 57). On price, Carbon’s per-token rate is a quarter of Fable 5.2’s through November 30 and half afterward, and its list price after December 1 equals Claude Opus 5.5’s $4 and $20. On the speed side, Artificial Analysis lists Carbon (high) at 25.6 minutes per task versus 45.2 for Fable 5.2 (max).

Both vendors point users to a cheaper default first: Google recommends Argon, and Anthropic recommends Opus 5.5 as the daily driver. Our head-to-head comparison takes this further with per-use-case picks, and the Fable 5.2 guide covers the Anthropic side. For earlier context, see best AI model for coding in October 2026, Claude Opus 5.5 vs Sonnet 5.5 for coding, GPT-6 Astra vs Sol vs Luna and the Claude Fable 5.1 guide.

Which model for which task

Limitations

• Verbose and slow at high effort. Artificial Analysis lists Carbon (high) at 205M output tokens on its index, well above the median, and a 67-second first answer token. Google’s model card admits occasional slowness or timeouts and extra tokens at higher thinking levels.
• Not the top of the broad index. Fable 5.2 leads by five points as of November 11, 2026, and wins several science and repository-grade coding boards.
• Hallucination is not zero. Artificial Analysis recorded an 11% hallucination rate on AA-Omniscience on October 28, up from Argon’s 4% but still among the lowest listed.
• Pricing doubles on December 1. Budget for $4 and $20, not the introductory rates.
• No explicit caching or sampling controls. Implicit caching only, and temperature, top-p and top-k are ignored.
• Access is tiered. No free tier; Antigravity and the Gemini app need Ultra; the strongest cyber version needs Fairwind approval; Vertex AI availability was unspecified in launch materials per VentureBeat.
• Several headline claims have no public numbers. The CursorBench, WANDR and MKA comparisons in Google’s post omit the underlying scores and costs.
• /swarm is a preview. It burns quota quickly and Google gives no pass-rate benchmark for it.

Verdict

Carbon is a credible frontier model at a lower per-token price than its main rivals, with a clear role: the deliberate, token-hungry tier above Argon, best used for hard debugging, architecture, audits and science. It is not the broad leader (that is Fable 5.2 on the independent index as of November 11, 2026) and it is not free of cost traps, because the introductory price ends in three weeks and thinking tokens add up.

The practical plan: run a fixed set of your own hard tasks on Argon and Carbon at low, medium and high, record tokens, minutes and review outcomes, price the result at December rates, and then decide where Carbon earns its place. If you are also weighing Anthropic, read the Carbon versus Fable 5.2 comparison and the Fable 5.2 complete guide next.

FAQ

Sources

Sources checked November 11, 2026.

• Gemini 4 Carbon is now available – Google blog, Nov 10, 2026 (GA, pricing, access, safety, scientist program)
• Gemini 4 Carbon: our next frontier model – Google blog, Oct 28, 2026 (announcement, cyber results, Fairwind)
• Gemini 4 Carbon is now available for developers – Google blog, Nov 10, 2026
• Gemini 4 Carbon model card – Google DeepMind (inputs, cutoff, benchmark table, safety table)
• Gemini 4 Carbon model page, What’s new in Gemini 4 Carbon, pricing and Latest Gemini models – Gemini API docs (model ID, quickstart, long decode, migration)
• Gemini 4 Carbon and /swarm and Swarm (/swarm) docs – Google Antigravity
• Gemini 4 Carbon is the new #1 (Oct 28), model page, leaderboard and Fable 5.2 vs Carbon – Artificial Analysis (independent)
• X posts: Google DeepMind, Oct 28, Google AI, Google DeepMind, Nov 10, Demis Hassabis and Cursor
• VentureBeat, Nov 10, 2026, The Verge, Nov 10, 2026 and Ridge, Nov 10, 2026 – press and secondary analysis, labelled as such
• YouTube: Gemini 4 Carbon vs Claude Fable 5.2 – creator roundup, secondary commentary