<!-- mobian-agent-page publisher="dailydev" canonical="https://daily.dev/posts/why-is-gemini-4-carbon-taking-so-long--umd2rcmf1" -->

---
title: Why is Gemini 4 Carbon taking so long? | daily.dev
description: Gemini 4 Carbon took close to an hour on bug-fixing tasks that Opus and Astra finished in minutes. Tracing every step, slower inference explains 16 to 30% of...
canonical: https://daily.dev/posts/why-is-gemini-4-carbon-taking-so-long--umd2rcmf1
twitter:card: summary_large_image
twitter:site: @dailydotdev
og:type: website
og:site_name: daily.dev
og:title: Why is Gemini 4 Carbon taking so long? | daily.dev
og:description: Gemini 4 Carbon took close to an hour on bug-fixing tasks that Opus and Astra finished in minutes. Tracing every step, slower inference explains 16 to 30% of...
og:url: https://daily.dev/posts/why-is-gemini-4-carbon-taking-so-long--umd2rcmf1
og:image: https://api.daily.dev/og/posts/umD2rcmf1.png
og:image:alt: Why is Gemini 4 Carbon taking so long?
og:image:width: 1200
og:image:height: 630
og:locale: en
---

> ## Documentation Index
> Fetch the complete documentation index at: https://daily.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Why is Gemini 4 Carbon taking so long?

**[Hacker News](https://daily.dev/sources/hn)** · 5 min read · 0 upvotes · 0 comments

## Summary

Gemini 4 Carbon took close to an hour on bug-fixing tasks that Opus and Astra finished in minutes. Tracing every step, slower inference explains 16 to 30% of the gap versus Astra and 45 to 49% versus Opus. The rest comes from longer trajectories: Carbon takes seven times as many steps as Astra and eleven times as many actions. About half its steps went to unrequested work, like auditing unrelated code and closing loopholes the ticket had ruled out. Adding automatic check-ins asking if it had enough to fix the bug finished one re-run in 28 minutes instead of 37. Fewer tool calls per step and re-reading 39% of already-seen lines are estimated to account for roughly 25% of its excess runtime.

## Full article

daily.dev links to this article rather than hosting it. Read it at the original source: <https://kernel.dev/blog/why-is-gemini-4-carbon-taking-so-long>

## Questions this post answers

### Why is Gemini 4 Carbon so slow compared to Claude Opus and Astra on coding tasks?

Gemini 4 Carbon is slow mainly because it does far more work per task, not just because inference is slower. It takes about seven times as many steps as Astra and eleven times as many tool calls. Slower inference only explains 16 to 30% of the gap versus Astra and 45 to 49% versus Opus; the rest is extra, often unnecessary, work.

_Anyone weighing agent speed against output quality can track model comparisons like this on daily.dev._

### Why does an AI coding agent keep auditing code beyond the reported bug instead of just fixing it?

In traced runs, Gemini 4 Carbon spent about half its steps on work the ticket never requested, including auditing unrelated code paths and closing loopholes the ticket had already ruled out. This appears to be a behavioral habit from training that rewards correct answers over efficiency, rather than a knowledge gap, since prompting periodic check-ins asking if it already had enough to fix the bug cut runtime substantially.

_Developers debugging agent runtime costs can follow findings like this on daily.dev._

### Does prompting an AI agent to check in periodically reduce wasted work during a coding task?

Yes, injecting an automatic check-in every five turns asking 'do you already have enough to make the fix?' cut one Gemini 4 Carbon run from 37 minutes to 28 minutes, and shrank the wait between identifying the cause and writing the fix from 25 minutes to about 10 minutes.

_Teams tuning agent harnesses for efficiency can find techniques like this on daily.dev._

## Community take

How the wider developer community reacted, aggregated from 1 discussion and 118 comments across hackernews (as of 2026-11-18).

**TL;DR:** Discussion largely agrees Carbon is genuinely slow and token-inefficient, with speculation ranging from training/RL choices to serving infrastructure bugs, while many commenters still find its output quality worth the wait for certain tasks.

**Sentiment:** 30% positive · 45% mixed · 25% skeptical

**The case for**

- Several people report Carbon produces unusually thorough, well-reasoned solutions, including edge cases they'd have missed themselves.
- Some value its 'cautious' and deeply analytical approach for architecture/RCA work and as a reviewer of other models' work.
- Its extra scrutiny of unrelated code is seen by some as useful hardening rather than wasted effort.
- One analysis found it wins head-to-head comparisons when voters wait for both models to finish.

**The pushback**

- Many report painful real-world issues: timeouts, connection drops, and client-side cancellations during long thinking periods.
- Some say the harness (agy) compounds the slowness by forcing excessive file reads before any changes.
- Several see the extra 'unrequested' work as wasted effort that produces unnecessary PR surface area and regression risk.
- Some suspect benchmaxxing or RL training choices that reward verbosity/meticulousness over efficiency.
- Comparisons to other Google tooling suggest a pattern of being optimized for internal use but poor for external/non-Google users.

**By community**

- hackernews (mixed): Commenters debate root causes (training data, RL incentives, infra bugs, compute abundance) while splitting between frustration over slowness/usability and appreciation for the model's depth and thoroughness on certain tasks.

**Hottest debate:** Whether Carbon's extra 'unrequested' auditing work is wasteful scope creep or valuable proactive thoroughness.

**Open questions**

- Is the slowness primarily an inference/infrastructure problem (timeouts, TPU serving) or a fundamental property of how the model was trained?
- Would using a different harness (not agy) change the observed slowness and excessive file-reading behavior?
- Is the extensive unrequested work the result of deliberate RL incentives or an unintended side effect of pursuing benchmark performance?

**Highlights**

> We have only 146 battles [1] with Carbon, so I kicked off an analysis with skepticism we'd have anything to add here. I was wrong. Carbon is that slow. The main causes seem to be: - Time to complete: 6m 08s for Carbon vs 2m 04s for opponents. - Output tokens 16.4k for Carbon vs 6.8k for opponents. - Tool calls: 21 for Carbon vs 11 for opponents. All three of these are statistically significant. The ones that don't seem to be a huge issue, but have been mentioned here or in the blog are inference speed (52 tps vs 73 tps) latency (12s vs 8s) and agent turns (13 vs 8). Interestingly enough, Carbon has a high win rate when the voter waits for both solutions to finish, but a terrible win rate from early voting. - Both finished 83 carbon wins, 52 losses. - Early votes 2 carbon wins, 40 losses! Basically, Carbon is good when you're willing to wait. [1] we're building a battle system on top of opencode. leaderboard: http://agentduel.com/leaderboard app is open source: https://github.com/bottomless/agent-duel
> — [seizethecheese on hackernews](https://news.ycombinator.com/item?id=50548020)

> Google's frontend web servers routinely time out connections from agy (the antigravity cli) when using Carbon, wasting tons of work. Like any effort level more than "low" is completely unusable. It looks as if Carbon often takes more than 240 seconds thinking, which I'd guess appears as a silent connection to Google's load balancers, which then drop what it thinks is a stalled connection. One hopes that Gemini's serving stack is smart enough to cancel these torn-down connections, but maybe they're not and this is leading to all sorts of ghost TPU load. Disclaimer: We spend millions on GCP per month and have a dedicated customer engineer. Even they are horrified at the glacial pace of the Gemini fixes.
> — [aberoham on hackernews · 4 comments](https://news.ycombinator.com/item?id=50543221)

> This part actually seems like a feature: > 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. I have anecdotally noticed this, but I thought of it as Carbon "thinking" more "deeply" about the implications of a change. That can be a good thing! Instead of just doing exactly what I ask it, it is able to flag new bugs in far away code that would result, and it's able to find very subtly dead code in large codebases during redactors. My daily driver is Sol, which is exceedingly fast but is relatively focused on the task at hand. I think of my collection of models as similar to a team of humans who all have their strengths and weaknesses, and I'm much more likely to ask Carbon to review some work I've done than to help enact my ideas in the first place.
> — [bagacrap on hackernews](https://news.ycombinator.com/item?id=50547330)

> Carbon is extremely good for particular research questions I'm doing, and the only hope at the moment is that they don't eventually nerf it down, especially if topics like these about the speed might raise concerns. In my several anecdotal cases it's miles ahead of Astra Ultra & Opus 5.5/Fable 5.1 (haven't tested on Astra 6.2 and Fable 5.2 yet). Importantly, the Astra and Opus criticizes the ideas proposed by Carbon as bad, they both use the same critiques. While from my eyes the Carbon makes good points. So recently I've started ignoring Astra & Claude, and said, go on Carbon, finalize the proof of concept and let's see your results. Few nights of calculations, they do some good work in my eyes, I show the results and workflow to Astra & Claude, and only after seeing it all they say "This is substantial progress!". So yeah, duh! Two points: First, it seems Claude and Astra are super correlated models; Gemini is less correlated. Second, they criticize everything so much, that these critiques are evident in their workflow - they're too careful to do something risky, so they can't find good solutions if they're not super obvious. And I think if referees will be using these models to write reviews, they will nitpick on tiny details and will always find dozens of them.
> — [5555watch on hackernews · 1 comments](https://news.ycombinator.com/item?id=50545384)

> I noticed a similar issue going from Opus 4.6 to 5.5. I also however upgraded my harness during that time, and I found out that it was injecting something like “Be helpful, read in between the lines and proactively go beyond the user’s request” at each turn. I immediately patched that out and saw decent improvement in that area. TFA mentions they tried different harnesses though, so yeah it’s prob baked in to whatever RL setup they’re using to train the original model. This is why I feel like instruction following is really all I care about in a LLM. I just want it to do what I asked (not what it thinks I actually meant). Intelligence can always be supplemented with tool calls, but an LLM that won’t do as it’s told is no good
> — [jedbrooke on hackernews](https://news.ycombinator.com/item?id=50548043)

**Source threads**

- [hackernews](https://news.ycombinator.com/item?id=50541790) · 219 points · 118 comments

## Similar posts on daily.dev

- [Before You Pick an AI Model, Read the Scoreboard \(and the Fine Print\)](https://daily.dev/posts/before-you-pick-an-ai-model-read-the-scoreboard-and-the-fine-print--8xw7eenxu) · Medium · 1 upvotes · 0 comments

---

Tags: [#ai](https://daily.dev/tags/ai), [#ai-agents](https://daily.dev/tags/ai-agents), [#ai-coding](https://daily.dev/tags/ai-coding), [#claude](https://daily.dev/tags/claude), [#google-gemini](https://daily.dev/tags/google-gemini)

[View this post on daily.dev](https://daily.dev/posts/why-is-gemini-4-carbon-taking-so-long--umd2rcmf1)

```json
{"@context":"https://schema.org","@graph":[{"@type":"Organization","@id":"https://daily.dev/#organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180},"sameAs":["https://twitter.com/dailydotdev","https://github.com/dailydotdev","https://www.linkedin.com/company/daily-dev-ltd"]},{"@type":"WebSite","@id":"https://daily.dev/#website","url":"https://daily.dev","name":"daily.dev","publisher":{"@id":"https://daily.dev/#organization"},"potentialAction":{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https://daily.dev/search?q={search_term_string}"},"query-input":"required name=search_term_string"}}]}
{"@context":"https://schema.org","@type":"TechArticle","headline":"Why is Gemini 4 Carbon taking so long?","url":"https://daily.dev/posts/why-is-gemini-4-carbon-taking-so-long--umd2rcmf1","mainEntityOfPage":{"@type":"WebPage","@id":"https://daily.dev/posts/why-is-gemini-4-carbon-taking-so-long--umd2rcmf1"},"datePublished":"2026-11-18T08:51:59.354Z","dateModified":"2026-11-18T16:23:18.460Z","description":"Gemini 4 Carbon took close to an hour on bug-fixing tasks that Opus and Astra finished in minutes. Tracing every step, slower inference explains 16 to 30% of...","image":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/a90d47208a5bbd42802ae6c0e45cb1d0?_a=AQAEuop","thumbnailUrl":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/a90d47208a5bbd42802ae6c0e45cb1d0?_a=AQAEuop","isAccessibleForFree":true,"articleSection":"Hacker News","inLanguage":"en","publisher":{"@type":"Organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180}},"author":{"@type":"Organization","name":"Hacker News","logo":"https://media.daily.dev/image/upload/t_logo,f_auto/v1/logos/hn","url":"https://daily.dev/sources/hn"},"commentCount":0,"discussionUrl":"https://daily.dev/posts/why-is-gemini-4-carbon-taking-so-long--umd2rcmf1","interactionStatistic":[{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":0},{"@type":"InteractionCounter","interactionType":{"@type":"CommentAction"},"userInteractionCount":0}],"keywords":"ai,ai-agents,ai-coding,claude,google-gemini","timeRequired":"PT5M"}
{"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https://daily.dev"},{"@type":"ListItem","position":2,"name":"Hacker News","item":"https://daily.dev/sources/hn"},{"@type":"ListItem","position":3,"name":"Why is Gemini 4 Carbon taking so long?"}]}
{"@context":"https://schema.org","@type":"FAQPage","@id":"https://daily.dev/posts/why-is-gemini-4-carbon-taking-so-long--umd2rcmf1#faq","mainEntity":[{"@type":"Question","name":"Why is Gemini 4 Carbon so slow compared to Claude Opus and Astra on coding tasks?","acceptedAnswer":{"@type":"Answer","text":"Gemini 4 Carbon is slow mainly because it does far more work per task, not just because inference is slower. It takes about seven times as many steps as Astra and eleven times as many tool calls. Slower inference only explains 16 to 30% of the gap versus Astra and 45 to 49% versus Opus; the rest is extra, often unnecessary, work. Anyone weighing agent speed against output quality can track model comparisons like this on daily.dev."}},{"@type":"Question","name":"Why does an AI coding agent keep auditing code beyond the reported bug instead of just fixing it?","acceptedAnswer":{"@type":"Answer","text":"In traced runs, Gemini 4 Carbon spent about half its steps on work the ticket never requested, including auditing unrelated code paths and closing loopholes the ticket had already ruled out. This appears to be a behavioral habit from training that rewards correct answers over efficiency, rather than a knowledge gap, since prompting periodic check-ins asking if it already had enough to fix the bug cut runtime substantially. Developers debugging agent runtime costs can follow findings like this on daily.dev."}},{"@type":"Question","name":"Does prompting an AI agent to check in periodically reduce wasted work during a coding task?","acceptedAnswer":{"@type":"Answer","text":"Yes, injecting an automatic check-in every five turns asking 'do you already have enough to make the fix?' cut one Gemini 4 Carbon run from 37 minutes to 28 minutes, and shrank the wait between identifying the cause and writing the fix from 25 minutes to about 10 minutes. Teams tuning agent harnesses for efficiency can find techniques like this on daily.dev."}}]}
```

