Gemini 4 Carbon is now available

I’ll research this announcement before writing, so the specs and pricing in the article are accurate.## Gemini 4 Carbon is now available

Gemini 4 Carbon’s initial API price is $2 per million input tokens and $10 per million output tokens through November 30. That works out to $0.002 per 1,000 input tokens and $0.01 per 1,000 output tokens—cheap enough to justify testing in production workloads, but twice as expensive as Gemini 4 Carbon’s standard rates once the introductory period ends on December 1.

The more important news, however, is not the discount. Google has opened Carbon to paid developers through Google AI Studio and the Gemini API, as well as to enterprise customers, scientists, and consumers. Carbon is Google’s new frontier model, with particular emphasis on cybersecurity, long-horizon agentic workflows, complex software engineering, enterprise knowledge work, and scientific reasoning.

In practice, this is a significant expansion of Gemini 4 from a narrow release into a broadly testable platform model.

What Google actually released

Carbon was first introduced in late October through the Fairwind program, initially focused on cybersecurity defenders. Its wider availability now gives ordinary paying developers the chance to evaluate those capabilities directly rather than relying on demonstrations or early-access anecdotes.

The model accepts up to 1,048,576 tokens of context. That makes it directly comparable with the 1M-token context available across Google’s modern Gemini stack and the 1M-context Claude families. A large repository, a long-running incident timeline, or a substantial collection of enterprise documents can therefore fit into one request without the application team manually building an elaborate retrieval pipeline.

But context length is only a capacity constraint. The more consequential feature is Carbon’s emphasis on sustained work: maintaining state, reasoning across many steps, and continuing toward a complex objective rather than producing a plausible next turn.

That distinction matters for applications such as:

• Investigating a security incident across logs, source code, alerts, and policy documents.
• Refactoring a large codebase while preserving behavior across many components.
• Preparing a technical decision memo from conflicting internal sources.
• Coordinating multi-step research or data-analysis workflows.
• Running an agent whose task takes dozens or hundreds of tool calls.

In my experience with agentic systems, the difficult part is rarely the first tool call. It is preserving intent, recognizing contradictory intermediate results, recovering from a failed action, and avoiding a premature conclusion. Models marketed as “agentic” often perform well in a short demonstration but degrade once a task requires a long chain of decisions. Carbon’s explicit long-horizon positioning is therefore the claim most worth testing.

Pricing: the introductory rate is not the long-term rate

Gemini 4 Carbon’s published API pricing has several tiers:

For a concrete workload, consider an agent that sends 50,000 input tokens and receives 4,000 output tokens on every turn.

At the introductory standard price, 100 turns cost:

Input:  50,000 × 100 / 1,000,000 × $2  = $10
Output:  4,000 × 100 / 1,000,000 × $10 = $4
Total                                      $14

At the post-promotion standard price, the same workload costs $28. A successful agent might run fewer turns, but a retry loop can consume that apparent saving quickly.

This is where context caching becomes important. If the repeated 50,000-token prefix is cacheable, 100 turns cost approximately:

Cached input: 50,000 × 100 / 1,000,000 × $0.10 = $0.50
Output:       4,000 × 100 / 1,000,000 × $10      = $4.00
Total                                               $4.50

The cache-aware total is about 69% below the introductory uncached estimate. Teams should therefore design their prompt structure around stable prefixes—such as system instructions, tool schemas, and reference documents—rather than treating caching as an afterthought.

What makes it scientifically interesting

One particularly concrete result involves the CASP17 blind test set. Across seven low-homolog protein families, Carbon increased the number of homologs retrieved by an average of 40-fold. More useful candidate sequences can improve the information available to structure-prediction models without retraining them.

The distinction is important: Carbon did not necessarily predict every protein structure better. It improved the upstream search step and expanded the candidate space available to another model. That is a common pattern in real AI systems. Improving retrieval, tool selection, or hypothesis generation can produce more value than making the final generation component incrementally larger.

Broader benchmarking is still underway, so this result should not be treated as proof that Carbon dominates every scientific workload. It does, however, provide a meaningful test of the model’s ability to navigate unfamiliar technical material and make useful connections beyond exact-match lookup.

How Carbon compares with the current model landscape

The direct comparison is not simply “Carbon versus Gemini 3.” Carbon represents a move from a general Gemini 3 tier toward a frontier model optimized for difficult, extended work.

The important comparison is task economics, not leaderboard position. Carbon may be unnecessary for classification, extraction, rewriting, or straightforward code generation. For those jobs, an earlier Gemini tier, Gemini 3, or a smaller model may deliver adequate results at much lower cost.

It becomes more interesting when a request requires a large amount of source material plus many reasoning steps. The same 1M-token context ceiling does not make models interchangeable: tokenization, retrieval behavior, tool calling, instruction adherence, latency, and output quality all affect the finished system.

Carbon’s immediate competitor in that category is the premium end of the Claude family. Carbon offers a distinctive combination of long-context work, agentic execution, and Google’s ecosystem. Claude’s current models retain the same 1M context scale, so teams should compare their actual workflows rather than assuming context length is a differentiator. A multi-model evaluation is usually more informative than selecting a winner from a generic benchmark.

GPT-6 Astra and GPT-6 Sol provide another axis of choice. Treating them as one GPT-6 “capability level” would hide potentially meaningful differences in latency, price, and task quality. Their names suggest tiers, not interchangeable endpoints, and each should be tested separately against Carbon on representative prompts.

How to test Carbon responsibly

Start with a production-shaped evaluation rather than a prompt gallery. Capture 50 to 100 real requests from the application, including ordinary successes, ambiguous cases, tool failures, and cases requiring intervention.

Then compare at least four configurations:

candidates = [
    "gemini-3",
    "gemini-4-carbon",
    "claude-sonnet-5",
    "gpt-6-sol",
]

for model in candidates:
    for task in representative_tasks:
        result = run_task(model, task)
        record(result)

Track more than token cost:

• Task completion rate.
• Correct tool sequence.
• Number of retries.
• Human correction time.
• Latency at the 50th and 95th percentiles.
• Total cost per successful task.
• Error rate when tool output is malformed or incomplete.

For long-horizon workflows, run the same task five times. A model with a slightly lower average score but much greater variance can be the worse production choice if it triggers expensive retries.

Also test safety boundaries. A cybersecurity-oriented model must not be equated with an autonomous vulnerability scanner. Define allowed targets, prohibit exploitation of systems outside the test scope, require human approval for destructive actions, and maintain complete tool-call audit logs.

Practical takeaways

• Gemini 4 Carbon is now a practical API option, not merely a research preview or restricted security release.
• Its strongest pitch is sustained, complex work, especially cybersecurity, software engineering, enterprise analysis, and scientific reasoning.
• Treat $2/$10 as a temporary launch price. Budget around $4 input and $20 output per million tokens after December 1 unless another rate applies to your account.
• Design for caching from the first prototype. In a repeated-turn agent, stable cached context can reduce input cost by 95% versus the introductory uncached rate.
• Do not replace Gemini 3 blindly. Establish a representative evaluation set and compare total cost per successful task.
• Benchmark premium alternatives separately. Carbon, Claude Opus 5.5, Claude Sonnet 5, GPT-6 Astra, and GPT-6 Sol should face the same tools, prompts, and success criteria.
• Keep a multi-model path. For organizations that want to compare Claude, GPT, Gemini, and other models without managing every vendor relationship directly, AI Prime Tech can provide cheaper access to Claude and multi-model APIs once or twice, making fallback and routing experiments more economical.

Gemini 4 Carbon’s arrival gives developers a more serious option for long-running, tool-using work. The real decision is not whether it tops a leaderboard. It is whether its combination of context, agent reliability, latency, and eventual price beats a more conservative model on the workflows you actually need to complete.