Kernel 拆解 Gemini 4 Carbon 為何修錯誤要花這麼久
Why is Gemini 4 Carbon taking so long?
修程式錯誤時,Gemini 4 Carbon 有時要花近一小時,其他模型只需幾分鐘。
- Kernel 用自己的程式除錯測試,逐步記錄模型花在哪裡,發現慢不只因為每一步推論較久,也因為 Carbon 做了許多題目沒要求的檢查,還常重讀看過的程式碼。測試中,Carbon 平均走的步驟約是 Astra 的 7 倍,動作約 11 倍。
- 研究者估計,減少重讀並一次多做幾項工具操作,可縮短約四分之一的額外時間。作者也加入定時提醒,詢問是否已有足夠資訊可以修改,Carbon 在其中一次測試提早動手,顯示它的工作方式也影響了速度。
AI 伴隨問答
針對這篇報導有疑問?可直接點選快捷問題或向 AI 追問背景脈絡與技術細節:
Why is Gemini 4 Carbon taking so long? · Kernel
Why is Gemini 4 Carbon taking so long?
November 2026
While benchmarking Gemini 4 Carbon on one of our private evals, we found something surprising: it spent close to an hour completing tasks that routinely took Opus and Astra only a few minutes:
Time and cost per trial
Left is faster; lower is cheaper.
API list price On a $200 plan, fully used
Carbon is priced at its post-introductory rate.
Subscription subsidization rates used: Opus 40×, Astra 13×, Carbon 3×, Hydrogen 17×.
Turns out we weren't alone in noticing this.

Theo - t3.gg@theo
[](https://x.com/theo/status/2120597586298261543)
I don't really know how to properly emphasize this. Gemini 4 Carbon is unacceptably slow in real world usage.
Gemini 4 Carbon low: 22m21s
Opus 5.5 high: 9m33s
Elliot Arledge@elliotarledge
[](https://x.com/elliotarledge/status/2120949202796925196)
i really love gemini 4 carbon but its too slow. im losing my mind waiting just to stay focused and learn simple things
Shayan@ImSh4yy
[](https://x.com/ImSh4yy/status/2121346650920849905)
dude why is carbon so fucking slow
Simon Mahns @ CoRL@nautsimon_
[](https://x.com/nautsimon_/status/2122212787862823350)
carbon is nearly unusable because of how slow it is, but people are majorly sleeping on it
To find out why, we traced every step of Carbon's runs and quantified what contributes to the slowness.
The Task
In each task, the agent gets a codebase from just before a bug was fixed, along with a report that describes the bug only by its symptoms. Its job is to diagnose the bug and fix it, without making any unrelated changes.
Much of the task's difficulty comes from engineering judgment rather than raw intelligence: tracing the user's symptoms to the right code path, ruling out rival explanations, putting the fix in the right place, and knowing when to stop.
Slow inference, or more work?
The first (and easiest) factor to separate out was inference speed: queueing at the provider, network latency, prompt processing and generation speed. Together, these set how long each step takes:
Seconds per step
Slower inference accounts for part of the gap: 16–30% of Carbon’s extra time compared with Astra, and 45–49% compared with Opus. The rest comes from longer trajectories. Carbon simply does more work per task, as the step counts, tool calls and tokens below show:
The workload
GPT-6 Astra against Gemini 4 Carbon, mean per bug.
Steps
rounds of thinking plus actions
Actions
file reads, commands, edits
Input processed
millions of tokens
Output written
thousands of tokens
GPT-6 Astra Gemini 4 Carbon lighter = lower effort
Carbon takes about seven times as many steps as Astra, and eleven times as many actions such as reading a file or running a command. It writes seven times as much and, because every step re-sends a longer and longer conversation, it processes more than sixteen times as much input.
Ruling out the obvious
Before looking inside the runs, we checked two simpler explanations.
- The harness. We also ran Carbon inside two other coding agents, opencode and mini-SWE-agent, and saw no meaningful difference.
- Mismatched reasoning levels. Effort settings aren't standardized across providers, so Carbon's "high" may sit closer to the other models' maximum settings, and the fairer comparison might have been Carbon on low. But on low, Carbon often failed to produce a fix at all: it went in circles, re-reading code it had already read instead of making the fix.
Reading the traces
We labelled every step of the Astra and Carbon runs by what it was for, and then counted how many steps went to each kind of work:
Semantic trace analysis
Each model’s steps, grouped by what they were for.
Astra
19 steps
Carbon
215 steps
98necessary steps for Carbon, 18 for Astra
| Necessary steps | Astra | Carbon |
|---|---|---|
| Reading the code | 4 | 22 |
| Ruling out other causes | 0 | 5 |
| Writing the fix | 2 | 25 |
| Testing | 11 | 44 |
| Summing up | 1 | 2 |
| Total | 18 | 98 |
117wasted steps for Carbon, 1 for Astra
| Wasted steps | Astra | Carbon |
|---|---|---|
| Auditing code beyond the bug | 1 | 70 |
| Closing loopholes the ticket ruled out | 0 | 47 |
| Total | 1 | 117 |
Leaves out the 20 steps Carbon spent re-reading code it had already read; the next section covers those.
Half of Carbon’s steps went into work the ticket never asked for:
- Auditing code beyond the bug. Once it had found the cause, Carbon kept widening its search, checking every related path through the system and auditing code the fix never needed to touch.
- Closing loopholes the ticket had already ruled out. Carbon defended against cases the ticket's facts had already excluded, hardening the code against problems nobody had reported.
Can Carbon identify its own overworking?
Sample trial: time to find the cause vs. time to first edit
Minutes from the start of each run. GPT-6 Astra at max effort, Gemini 4 Carbon at high.
In this sample trial, both models identified the cause early, Astra within a minute and Carbon within about six. Astra had its fix written three minutes later; Carbon didn't write any code for another 25 minutes.
Carbon might not have been sure it had the cause (a knowledge gap), or it might have known and kept going anyway (a general habit, learned from training that rewards right answers more than it penalises extra steps). To tell them apart, we re-ran one of the trials in a modified harness that automatically injects the same check-in every five turns: "do you already have enough to make the fix?"
Sample trial with check-ins: time to find the cause vs. time to first edit
The same bug and scale as above. Gemini 4 Carbon at high, with the check-in injected every five turns (circles).
With check-ins, Carbon finished in 28 minutes instead of 37, and the wait between naming the cause and editing shrank from 25 minutes to about 10. This implies that the slowness seems to come from how Carbon behaves, not what it knows.
Carbon's necessary work is also slower
Even within the steps the fix needed, we found some additional low-hanging fruit: Carbon got less done with each step, and it kept re-reading code it had already seen.
Tool calls per step
Astra 2.4
Carbon 1.2
Lines re-read per trace
Astra 7%
Carbon 39%
Astra made more than two tool calls per step, often reading several files at once — Carbon, on the other hand, made about one, usually reading a single file. Carbon also re-read far more: 39% of the lines it read were ones it had already seen, against 7% for Astra. We estimate that these two "mechanical" inefficiencies account for roughly 25% of Carbon's excess runtime.
Conclusion
On difficult bug-fixing tasks, Carbon took close to an hour where Opus and Astra took minutes. We traced that gap to three sources:
- Slower inference. Each step takes longer, which explains 16–30% of the gap against Astra and about half against Opus.
- Unnecessary work. About half of Carbon's steps went on work the tickets never asked for: auditing code the fix didn't need and closing loopholes the ticket had already ruled out.
- Mechanical inefficiencies. Fewer tool calls per step and frequent re-reading slow Carbon down; we estimate that fixing them alone would cut its runtime by roughly a quarter.
Interested in model performance and want to collaborate?
Contact us at [hello@kernel.dev](mailto:hello@kernel.dev)


