The author reports that, on office-style and math tasks, Carbon and Argon had the same listed price per million tokens with default thinking, but Carbon's total task costs were about 4.5 times and 3 times Argon's, respectively. The author reports that setting Carbon to thinking_level low left accuracy unchanged while reducing costs. The original post provides no raw API call logs, complete scoring rules, or itemized costs, so these results are a personal API self-test and should not be treated as an independently reproduced cost benchmark.
Tasks this may help assess: With fixed, short tasks such as structured extraction from emails, tiered commission calculations, short email generation, and 10 math problems, how thinking levels may affect this author's token use, latency, and costs.
Tasks this should not be generalized to: Long-running agent work, multi-file code changes, complex architecture planning, or other prompts, API configurations, workloads, or billing conditions. The author did not test long-running programming tasks.
Model versions covered: What the author calls Gemini 4 Carbon and Gemini 4 Argon; API model IDs and snapshot versions were not specified.
Test environment or client: The author says the tests were run through an API; the provider, endpoint, SDK, and call configuration were not specified.
Reasoning levels and parameters: Both models at default thinking; Carbon was also tested with thinking_level low. Temperature, maximum output, caching, prompts, and other parameters were not specified.
The author says they used three types of office tasks, running each three times: extracting fields from messy emails, calculating tiered commissions, and writing a 120-word apology email. Results were scored by code. They also used 10 difficult math problems requiring exact answers, running each once. Carbon and Argon were compared at the default thinking level; the low-level results were reported separately by the author.
The original post does not publish the task prompts, email and calculation inputs, code scorer, individual checkpoints, per-run outputs, or API usage details. The denominator for the reported office-task accuracy is 45, but the author does not explain how it corresponds to the three task types and three runs per type. The counting method for thinking tokens is also unspecified.
The table below groups the scattered figures in the original post by task set. Costs are the author-reported total cost for each task set in US dollars, and tokens are the counts labeled by the author as thinking tokens. The original post provides no itemized bills or table that would allow the figures to be checked.
| Task set and level | Author-reported result | Thinking tokens | Total cost (USD) |
|---|---|---|---|
| Office tasks, default Carbon | 45/45 | 5,239 | $0.0669 |
| Office tasks, default Argon | 44/45; the only lost point was an email of 123 words, over the 120-word limit | 0 | $0.0148 |
| Difficult math problems, default Carbon | 10/10 | 10,982 | $0.1461 |
| Difficult math problems, default Argon | 10/10 | 1,018 | $0.0494 |
Office tasks, Carbon thinking_level low | 45/45 | 0 | $0.0147 |
Difficult math problems, Carbon thinking_level low | 10/10 | 0 | $0.0459 |
Based on the total costs provided by the author, the default Carbon-to-Argon cost ratios are about 4.52 for office tasks and 2.96 for math problems. The author says the costs at the low level matched Argon's costs for the corresponding task sets, but the post does not provide separate test data for Argon at a low level.
The author also reports that median latency per office-task call was 9.5 seconds for Carbon and 5.9 seconds for Argon. For the integral of ln(sin x), Carbon used 3,836 thinking tokens and took 40.9 seconds; Argon used no thinking tokens, took 10.1 seconds, and answered correctly. Carbon's thinking-token count ranged from 555 to 1,031 across runs of the same email task. In 3 of 19 low-level calls, latency was 34 to 54 seconds; the author says the reason was unknown.
Prices stated in the original post: $2 input and $10 output per million tokens. The author says Carbon and Argon had the same unit price at the time, with the price in effect through November 30. This is the original post's description of a limited-time price when it was published on 2026-11-11, not a current or long-term price. The post provides no link to the price source and does not break down the input and output token costs included in the reported totals.
Counts and units: Office tasks: 3 types × 3 runs each; difficult math problems: 10 problems, 1 run each. Accuracy is recorded as in the author's post: 45/45, 44/45, and 10/10. Thinking tokens are token counts, latency is in seconds, and costs are in US dollars. The call sets included in the total costs, including any retries, caching, or other charges, were not disclosed.
Table note: The Reddit post presents the figures in paragraphs and bullet points, not as a source table. The table above reorganizes the author's account and does not represent additional measurements.
Comments: u/xapep speculated that thinking may add overhead on fixed-format tasks and suggested setting levels by route; this was the commenter's view, not a finding from the author's experiment. Commenter u/EmbarrassedParty762 suggested that the value of heavier thinking may emerge in multi-file refactors or complex architecture planning. The author replied that they had not tested those tasks and could not assess the benefit. The author also replied that 3 of 19 low-level calls took 34–54 seconds despite using 0 thinking tokens.
This report indicates that, on the limited tasks tested by the author, default-thinking Carbon used more thinking tokens, showed little or no accuracy advantage, and produced a higher bill. The author's low-level results suggest that, on these tasks, the same scored results may be maintained at lower cost. This supports local trials on similar, short tasks only; it does not show that Carbon has no benefit on complex coding tasks.
The comparison is also limited by unreported model snapshots, API provider and configuration, complete token billing, scorer implementation, and small sample size. In particular, each math problem was run only once, so variation cannot be estimated; the author also notes that Carbon's thinking-token count varied across runs. The limited-time unit price in the original post was valid through November 30 and cannot be used to infer later prices or long-term costs.
To verify this report, first obtain the task inputs and scorer that the author did not publish, along with per-call records, API model IDs and configuration. Then fix model versions and thinking levels separately, repeat each task type multiple times, and record input, output, and thinking tokens, latency per call, and bills broken down at current prices. Assessing Carbon's value for long-running coding would require separate, verifiable multi-file engineering tasks. The information published in the original post alone is insufficient to reproduce the costs and 45 scored items precisely.
Gemini 4 Carbon