Google releases Gemini 4 Carbon: a 1 million-token window for complex debugging

When a bug spans three services, fixing one file often only masks the underlying cause. Google has released Gemini 4 Carbon for tasks like these: the model is designed for extended debugging that involves testing hypotheses. Developers may want to try it on a problem where their usual assistant is already going in circles, then compare the cost of an accepted fix.

The claim that it is “available to everyone” needs qualification. Access in the Gemini app, search AI Mode and Antigravity is available to Google AI Ultra subscribers. Developers can use a paid API. The terms are listed in Google's announcement.

What working on a complex bug looks like

Imagine an online store: a customer retries a payment after a timeout and is charged twice for the order. This is a hypothetical example. The cause could lie in the interactions between the payment handler, the event queue and the retry logic. A useful result here would be a test that reproduces the bug, an explanation of the sequence of events and a fix that handles message redelivery correctly.

Carbon is designed for precisely this kind of multistep investigation. In its model card, Google explains that it uses more reasoning tokens than Argon to explore hypotheses and run additional checks. The reasoning level is configurable, with corresponding changes in latency and cost.

Before testing it on your own project, define the success criteria. For example: a retried request does not create a second payment, the queue supports message redelivery, and existing refund flows continue to work. That makes the result verifiable regardless of how convincing the model's answer sounds. A polished explanation without a reproduction of the bug leaves the original engineering problem unresolved.

Antigravity has also introduced a preview of /swarm: a single prompt launches a coordinated team of agents. According to Google, Carbon can be assigned architecture, coordination or auditing work, while lighter models handle parallel tasks. For the payment example, it would make sense to separate reproducing the bug, preparing the patch and checking for side effects. This is a proposed workflow; its effectiveness still needs to be measured on your code.

A million tokens calls for careful budgeting

Carbon's model card specifies a combined input and output window of up to one million tokens. Promising “a million tokens of input plus another million for the answer” would therefore be incorrect. When loading a large repository, you need to leave room for the output. The window size alone also does not prove that the model will find the relevant dependency among all the files.

In practice, I would start with a minimal set: related modules, logs, an event-flow diagram and a test that reproduces the bug. Add more context when the investigation reveals a specific gap. This makes it easier to understand which information helped and to compare multiple runs.

Through November 30, the stated price is $2 per million input tokens and $10 per million output tokens. From December 1, those prices rise to $4 and $20 respectively. Google lists these rates in its announcement. The duration of the work also matters for budgeting: additional verification cycles can increase spending even when the per-token price looks attractive.

What to check before adoption

Google reports that Carbon leads on CursorBench 4.0, WANDR and AutomationBench, with a lower cost per task than the next-best external model. That is a useful reason to run your own test. Applying a benchmark table's result to a specific repository without measurements would be premature.

The model card explicitly lists hallucinations, potentially slow performance and timeouts. The team's choice of metrics is particularly revealing: how many fixes pass independent verification, how long the investigation takes and how much the entire run costs, including retries.

For an initial trial, take several complex bugs that have already been solved and hide the finished patches. Compare Carbon with your current tool under identical conditions. This gives developers a verifiable answer about debugging quality, product managers data on latency and founders the cost of a useful result. Those three measures should guide decisions about which tasks warrant more expensive reasoning.