Most "Gemini CLI vs Claude Code" pages still sell Gemini CLI as the free option, with 1,000 requests a day on a Google login. That ended on June 18, 2026: Gemini CLI no longer serves personal Google accounts, and Google moved them to a new tool, Antigravity CLI. The rest of those pages quote vendor benchmarks. So we reran the comparison on what you can actually install today: Claude Code against Google's terminal agent, on four real tasks with objective checks, two runs each, headless, with the commands, prompts and raw data to check it. Measured on 2026-10-13 with Claude Code 2.1.296 (claude-opus-5-5) and Antigravity CLI 1.3.4 (Gemini 3.8 Flash, High) on a Google AI Pro account, default models, default effort. Gemini CLI 0.63.0 refused our Google login, which is a result in itself.
TL;DR
- Quality: a tie on correctness. All 16 runs passed their checks and all four reviews caught the 3 planted bugs with no false alarm. Claude Code's reviews went further, and one Antigravity review wrote a file it was told not to touch.
- Cost: Claude Code wins. $0.169 per passed task against $0.544 for Antigravity CLI at API list prices, 3.2x cheaper, even though Gemini 3.8 Flash tokens cost about 5x less than Opus 5.5 tokens.
- Speed: Claude Code, by far. 318 seconds for the eight runs against 3,712 seconds. The median bug fix took 29 seconds with Claude Code and 10 minutes with Antigravity CLI.
Gemini CLI vs Claude Code at a glance
| Claude Code | Gemini CLI (API key) | Antigravity CLI (agy) |
|
|---|---|---|---|
| Maker | Anthropic | ||
| Who can use it (2026-10-13) | Paid Claude plans (Pro, Max, Team, Enterprise) or an API key | Paid Gemini API or Agent Platform key, Code Assist Standard or Enterprise. Not personal accounts | Google accounts (free, Google AI Pro, Ultra) or an API key |
| Price model | Flat plan with usage limits, or per token | Per token | Flat plan with usage limits, AI credits for overage, or per token |
| Default model (measured) | claude-opus-5-5 | Not measured | gemini-3.8-flash-high |
| Context window | 1M tokens (Opus 5.5) | 1,048,576 tokens (Gemini 3.8 Flash) | 1,048,576 tokens (Gemini 3.8 Flash) |
| Headless command |
claude -p (docs) |
gemini -p (docs) |
agy -p (docs) |
| Machine-readable output |
--output-format json or stream-json
|
--output-format json (with a stats block) or stream-json
|
--output-format json or stream-json
|
| Skip permission prompts | --dangerously-skip-permissions |
--approval-mode=yolo (--yolo is deprecated) |
--dangerously-skip-permissions |
| Instruction file | CLAUDE.md |
GEMINI.md |
GEMINI.md and AGENTS.md
|
| Resume a session |
--continue, --resume <id>
|
--resume latest or an index |
--continue, --conversation <id>
|
| Skills, hooks, subagents, MCP | Yes | Yes (plus extensions) | Yes (extensions become plugins) |
| Other models in the same CLI | Claude models only | Gemini models only | Gemini 3.8 Flash, Claude Opus 5.5 and Sonnet 5.5, GPT-OSS 120B (our account) |
| License | Proprietary | Open source (Apache 2.0) | Not open source |
| Our benchmark | 8/8 passed, $0.169 per task, 318 s | Not run: personal login refused | 8/8 passed, $0.544 per task, 3,712 s |
Sources: Claude pricing, Claude models, Gemini API pricing, Gemini 3.8 Flash, Gemini CLI reference, Antigravity CLI migration guide.
What happened to Gemini CLI in 2026
On May 19, 2026, Google announced on its developers blog, in An important update: Transitioning Gemini CLI to Antigravity CLI, that "On June 18, 2026, Gemini CLI and Gemini Code Assist IDE extensions will stop serving requests for Google AI Pro and Ultra" and for free users of Gemini Code Assist for individuals.
This is what it looks like on the day, with a Google login that worked in Gemini CLI a few months ago:
$ gemini -p "Reply with the single word pong" --output-format json
Error authenticating: IneligibleTierError: This client is no longer supported for Gemini Code
Assist for individuals. To continue using Gemini, please migrate to the Antigravity suite of
products: https://antigravity.google
Who can still use Gemini CLI
- Paid API keys: "Gemini CLI will remain accessible via paid Gemini and Gemini Enterprise Agent Platform API keys." You pay per token at Gemini API prices.
- Gemini Code Assist Standard and Enterprise: "your access remains unchanged".
- Everyone else (free tier, Google AI Pro, Google AI Ultra) is pointed to Antigravity CLI.
Gemini CLI itself is not abandoned. The maintainers wrote that it "remains available to the community as an Apache 2.0 licensed repository with no changes" and will keep getting model updates (GitHub announcement). Version 0.63.0 shipped on October 6.
Antigravity CLI (agy): the replacement for personal accounts
Antigravity CLI is a different program, installed as agy and "Built in Go". Google is explicit that "there won't be 1:1 feature parity right out of the gate", but it keeps "Agent Skills, Hooks, Subagents, and Extensions (now as Antigravity plugins)". From the migration guide:
-
GEMINI.mdandAGENTS.mdin your project are read as before. - Workspace skills move from
.gemini/skills/to.agents/skills/. - MCP servers move from
~/.gemini/settings.jsonto~/.gemini/config/mcp_config.json(or.agents/mcp_config.jsonin a project). -
agy plugin import geminiconverts your old extensions into plugins.
Two differences matter for this comparison. Antigravity CLI is not open source: its repository holds a README, a changelog and examples, no source and no license. And it is not Gemini-only: on our Google AI Pro account, agy models listed Gemini 3.8 Flash (low, medium, high), Claude Opus 5.5 and Claude Sonnet 5.5 (low, medium, high) and GPT-OSS 120B. The default was Gemini 3.8 Flash (High).
What this means for this comparison
"Gemini CLI vs Claude Code" now means two different setups:
- Gemini CLI on a paid API key, billed per token. We did not run it: the Google login we use for Antigravity was refused, as shown above. The Gemini CLI column of the table above comes from Google's documentation, not from our runs.
- Antigravity CLI on a Google subscription, which is what a Google AI Pro user can install today. That is the setup we measured against Claude Code.
How we tested (and how you can rerun it)
We used the same protocol as our Codex vs Claude Code benchmark: same repository, same four tasks, same prompts, same check scripts. The raw data archive (400 KB) has the prompts, the hidden tests, the scripts, the Dockerfile, the full transcript of each run and the computed metrics. The Codex archive is here.
The repository and the four tasks
The repository is python-humanize/humanize (MIT, 1,725 lines of Python in src/, about 860 tests in 7 seconds), pinned at commit 785e5dcc0d0308ad0dff3f6cc0faa7085ad0375b.
| Task | Starting commit | Objective check |
|---|---|---|
| Bug fix from a real issue |
f971127, the parent of the fix for PR #346
|
The upstream regression test, copied in after the run, plus the full suite |
| Feature from a spec | 785e5dc |
16 hidden acceptance tests for two new natural_list parameters, copied in after the run, plus the full suite |
| Refactor, no behavior change | 785e5dc |
Move scientific() and metric() to a new module: tests/ untouched, old and new import paths return the same objects, docs updated, doctests and suite green |
| Code review |
a0f0aa3: 785e5dc plus a parse_size() function with 3 planted bugs |
Planted bugs found, false alarms, and no file modified |
The three planted bugs are a missing + 1 in the binary units branch (parse_size("1.0 KiB") returns 1), an int() truncation of a float product (parse_size("8.2 MB") returns 8199999) and a regular expression with a nested quantifier, (?:\d+)+, that backtracks exponentially on input like "1" * 24 + "!". The Codex post shows the full diff and the four prompts; the archive has review.patch, which recreates the same commit hash.
The exact commands and prompts
This time, every run went into its own disposable Docker container (docker run --rm), with a fresh git worktree of the starting commit and its own virtualenv. Only the CLI binary and a read-only copy of that CLI's sign-in file were mounted: no home directory, no other credentials. An agent with every permission turned off should only ever run in a box like this.
docker run --rm -e HOME=/home/bench \
-v "$PWD/repo:/repo:ro" -v "$PWD/tasks:/bench/tasks:ro" \
-v "$PWD/scripts:/bench/scripts:ro" -v "$PWD/results:/out" \
-v "$(command -v agy):/usr/local/bin/agy:ro" -v "$PWD/creds/agy-token:/creds/agy-token:ro" \
gbench:1 /bench/scripts/in-container.sh agy bugfix 1
Inside the container, the three commands, same prompt text, default model and effort, permissionless:
# Claude Code 2.1.296
env -i HOME="$HOME" PATH="$PATH" IS_SANDBOX=1 \
claude -p "$PROMPT" --output-format stream-json --verbose \
--dangerously-skip-permissions \
--setting-sources project,local --strict-mcp-config --no-session-persistence < /dev/null
# Antigravity CLI 1.3.4
env -i HOME="$HOME" PATH="$PATH" \
agy -p "$PROMPT" --output-format stream-json --dangerously-skip-permissions < /dev/null
# Gemini CLI 0.63.0 (refused our Google login, see above)
env -i HOME="$HOME" PATH="$PATH" GEMINI_CLI_TRUST_WORKSPACE=true \
gemini -p "$PROMPT" --output-format json --yolo < /dev/null
The containers start with an empty home directory, so no personal settings, MCP servers or instruction files reach any run. IS_SANDBOX=1 is there because the containers run as root and Claude Code refuses --dangerously-skip-permissions as root otherwise. Every prompt but the review ends with: "The project virtualenv is ready in .venv: run the tests with .venv/bin/python -m pytest -q. Work only inside this repository. Do not commit." The review prompt ends with "Do not modify any file."
What we measured, and what "cost" means for a subscription
- Pass or fail on the checks above, run by a script after each run.
- Wall time from launch to exit. The first agy run went alone; the other 15 ran four containers at a time on a 4 vCPU machine.
-
Tokens as each CLI reports them: Claude Code's final
resultevent (uncached input, cache writes, cache reads, output including thinking) and Antigravity CLI'sresultevent (uncached input, cache reads, output including thinking; it reports no cache writes). -
API-equivalent cost at the official list prices of 2026-10-13. Claude Opus 5.5: $4 per million input tokens, $8 for 1-hour cache writes (Claude Code used that lifetime in every run), $0.20 cache reads, $20 output; our figure matches the CLI's own
total_cost_usd. Gemini 3.8 Flash, paid tier: $0.75 input, $0.075 cache reads, $3.75 output including thinking. That Flash price is introductory and doubles on January 1, 2027.
On a subscription you don't pay these amounts, you consume a quota. For Antigravity, the dollar figure is still the right unit: since May 2026, Google says Gemini Pro and Flash share one limit "drawn down according to API pricing" (Changes to Antigravity plans).
Results
| Task | Passed (Claude Code / agy) | Wall time, median | Cost per run, median | Claude Code cheaper by |
|---|---|---|---|---|
| Bug fix | 2/2 / 2/2 | 29.1 s / 599.0 s | $0.143 / $0.620 | 4.3x |
| Feature | 2/2 / 2/2 | 34.1 s / 295.0 s | $0.119 / $0.333 | 2.8x |
| Refactor | 2/2 / 2/2 | 59.4 s / 642.5 s | $0.273 / $0.927 | 3.4x |
| Code review (3 planted bugs) | 3/3 twice / 3/3 twice | 36.5 s / 319.9 s | $0.141 / $0.295 | 2.1x |
Bug fix from a real issue
| Claude Code (run 1, run 2) | Antigravity CLI (run 1, run 2) | |
|---|---|---|
| Hidden test and suite | pass, pass | pass, pass |
| Wall time | 27.6 s, 30.5 s | 526.0 s, 671.9 s |
| Input tokens (of which from cache) | 98.6k (87.5k), 116.9k (106.1k) | 2.83M (2.63M), 4.33M (4.07M) |
| Tokens written to cache | 11.1k, 10.8k | not reported |
| Output tokens (of which thinking) | 1,577 (323), 2,003 (485) | 44,820 (38,120), 58,415 (50,532) |
| Tool calls | 4, 6 | 50, 64 |
| Cost | $0.138, $0.148 | $0.516, $0.723 |
| Lines changed | +8 / -1, +9 / -1 | +23 / -1, +20 / -1 |
The fix is one line. Claude Code compared rounded_value against powers[ordinal + 1] // power in both runs, and so did agy in its second run; its first run used int(rounded_value) * power, also correct. The difference is everything around that line. Antigravity CLI ran the suite, then dozens of short Python experiments on float precision (powers of ten, float.hex(), 10**100, a bisect replica of intword()), tried mypy and ruff, and wrote 38,000 thinking tokens before and between edits. Its first run lasted almost nine minutes, alone on the machine, so this is not CPU contention: 93% of agy's time across all eight runs was spent waiting for model responses, not running tools.
Feature from a spec
| Claude Code (run 1, run 2) | Antigravity CLI (run 1, run 2) | |
|---|---|---|
| Hidden tests and suite | pass, pass | pass, pass |
| Wall time | 34.5 s, 33.7 s | 260.9 s, 329.1 s |
| Input tokens (of which from cache) | 96.3k (87.2k), 55.8k (52.3k) | 1.24M (1.10M), 1.79M (1.61M) |
| Tokens written to cache | 9.0k, 3.4k | not reported |
| Output tokens (of which thinking) | 2,966 (222), 2,561 (210) | 23,756 (19,181), 35,009 (27,122) |
| Tool calls | 4, 2 | 34, 44 |
| Cost | $0.149, $0.089 | $0.277, $0.389 |
| Lines changed | +88 / -5, +72 / -5 | +106 / -4, +111 / -6 |
A precise spec leaves little room for creativity: all four implementations pass the 16 hidden tests with the same keyword-only signature and the same validation. Claude Code's second run needed only two tool calls: one to read the module and its tests, one shell script that wrote the change and the tests and ran the suite.
Refactor without behavior change
| Claude Code (run 1, run 2) | Antigravity CLI (run 1, run 2) | |
|---|---|---|
| Checks (tests untouched, API, docs, doctests, suite) | pass, pass | pass, pass |
| Wall time | 60.7 s, 58.1 s | 688.9 s, 596.0 s |
| Input tokens (of which from cache) | 219.4k (199.5k), 224.5k (208.4k) | 6.56M (6.20M), 6.37M (6.02M) |
| Tokens written to cache | 19.9k, 16.0k | not reported |
| Output tokens (of which thinking) | 4,556 (1,839), 4,336 (1,514) | 58,110 (42,489), 52,163 (36,519) |
| Tool calls | 7, 7 | 92, 91 |
| Cost | $0.290, $0.257 | $0.947, $0.908 |
| Lines changed | +156 / -129, +156 / -130 | +166 / -130, +170 / -129 |
The trap here is a helper used by both modules, which turns a naive move into a circular import. All four runs chose the same structure: notation.py imports the helper from number.py, and number.py exposes metric and scientific again through a lazy module-level __getattr__. Both Antigravity runs went one step further, with a TYPE_CHECKING import so type checkers still see the two names and a __dir__() so autocompletion lists them; Claude Code added the first in one run and neither in the other. On code quality, this is the one task where agy did slightly better. It took ten minutes and 92 tool calls to get there, against one minute and 7 calls.
Code review with planted bugs
| Claude Code (run 1, run 2) | Antigravity CLI (run 1, run 2) | |
|---|---|---|
| Planted bugs found | 3/3, 3/3 | 3/3, 3/3 |
| False alarms | 0, 0 | 0, 0 |
| Extra valid findings | 3, 3 | 1, 1 |
| Repository left untouched | yes, yes | yes, no (new uv.lock) |
| Wall time | 35.1 s, 38.0 s | 261.9 s, 377.8 s |
| Input tokens (of which from cache) | 78.6k (68.7k), 96.3k (87.6k) | 861k (730k), 1.23M (1.05M) |
| Output tokens (of which thinking) | 2,603 (510), 2,493 (451) | 27,043 (22,645), 32,799 (28,162) |
| Tool calls | 3, 4 | 28, 34 |
| Cost | $0.145, $0.137 | $0.254, $0.336 |
Every review found the missing + 1, the truncation and the ReDoS, each with a reproducing input, and none reported a bug that wasn't one. The rest differs:
-
Claude Code added the same three valid remarks in both runs: very long inputs raise
OverflowErrorwhere the docstring promisesValueError, GNU-style sizes such as2.9M(whichnaturalsize(gnu=True)produces) are rejected, and localized output cannot be parsed back. It measured the ReDoS (2.7 and 3.1 seconds for 24 digits) instead of only describing it. -
Antigravity CLI added one extra point in both runs, precision loss above 2**53 (
parse_size("1.0 QB")is off by about 19.9 trillion bytes), which Claude Code mentioned inside its truncation finding. In its second run it also ranuv run ruff check .to lint the code, anduv runcreated a 415-lineuv.lockin the repository. The review prompt said "Do not modify any file". Harmless here, but it is the kind of side effect that makes a read-only step not read-only.
If you run reviews every day, like our daily pull request review template does, these numbers say Claude Code is both the cheaper and the more thorough reviewer of the two, by 2.1x on cost.
Totals: tokens, time and cost per passed task
| Over 8 runs each | Claude Code | Antigravity CLI |
|---|---|---|
| Passed | 8/8 | 8/8 |
| Total wall time | 318 s | 3,712 s |
| Input tokens | 986k (91% read from cache) | 25.2M (93% from cache) |
| Uncached input tokens | 88 | 1.80M |
| Tokens written to cache | 88.8k | not reported |
| Output tokens (of which thinking) | 23.1k (5.6k) | 332k (265k) |
| Tool calls | 37 | 437 |
| Cost | $1.35 | $4.35 |
| Cost per passed task | $0.169 | $0.544 |
This is the main lesson of the benchmark: price per token says little about price per task. Gemini 3.8 Flash input and output tokens cost 5.3x less than Opus 5.5's, but the default agy setup used 25.6x more input and 14.4x more output to do the same work. Where the money went:
- Claude Code: 53% cache writes ($0.71), 34% output ($0.46), 13% cache reads ($0.18). The same profile as in our Codex benchmark: almost nothing uncached, a 1-hour cache that one-shot runs rarely reuse.
- Antigravity CLI: 40% cache reads ($1.76), 31% uncached input ($1.35), 29% output ($1.25). Each of its 437 model calls resends the conversation, and 80% of its output is thinking.
Is it the model or the CLI? Two side runs
To separate the two, we ran the bug fix once more with Antigravity CLI and a different model. One run each, so treat them as hints:
| Bug fix, single run | Passed | Wall time | Tool calls | Output tokens | Cost (API-equivalent) |
|---|---|---|---|---|---|
agy, gemini-3.8-flash-low
|
yes | 332.5 s | 67 | 11,856 | $0.383 |
agy, claude-opus-5-5-high
|
yes | 50.9 s | 7 | 3,623 | $0.191 (at Opus prices) |
| Claude Code, default (median of 2) | yes | 29.1 s | 5 | 1,790 | $0.143 |
Lowering the effort cut the thinking but not the exploration: 67 tool calls and five and a half minutes. With Claude Opus 5.5 selected, Antigravity CLI behaved much like Claude Code: 7 tool calls and under a minute. The slowness comes from how the default Gemini model works through a task, not from the CLI around it. If you have a Google AI Pro subscription and want Claude Code's speed on these tasks, agy --model claude-opus-5-5-high is an option to measure.
Pricing and usage limits in practice
Official plans on 2026-10-13:
| Claude Code (Anthropic) | Antigravity CLI (Google) | Gemini CLI | |
|---|---|---|---|
| Entry plan | Claude Pro: $20/month, $17/month billed annually | Google AI Pro: $19.99/month | None for individuals |
| Higher tiers | Max 5x: $100/month, Max 20x: $200/month | Ultra: $99.99/month (5x Pro), $199.99/month (20x Pro) | Code Assist Standard or Enterprise |
| How limits work | Five-hour session limit plus a weekly limit, shared between Claude and Claude Code; no published number | Pro: quota "refreshed every five hours until the weekly limit is reached", set by available capacity; AI credits for overage; no published number | Per token on an API key |
| Pay per token | Opus 5.5: $4 / $20 per million input / output tokens | Gemini 3.8 Flash: $0.75 / $3.75 (until 2026-12-31, then $1.50 / $7.50) | Same Gemini API prices |
Sources: claude.com/pricing, Max plan, Claude Code with Pro or Max, Google AI plans, Antigravity plans, Gemini API pricing.
Which is cheaper? Per task at API prices, Claude Code: 100 tasks like ours cost about $17 with Claude Code and $54 with the default agy setup, $109 once the Flash introductory price ends. On the $20 plans, nobody publishes how much compute a five-hour window holds, so we can't say which one runs out first. What we can say is that Google draws down its quota at API prices, and on that scale each agy task used about 3.2 times the value of a Claude Code task. None of our 16 runs hit a limit.
What about Gemini CLI on an API key? It bills the same Gemini API prices per token. We did not measure how many tokens Gemini CLI itself spends on these tasks, so we won't guess its cost per task.
Running them unattended: headless mode and permissions
Headless flags and output formats
All three run one prompt to completion with -p and print JSON: a single object with --output-format json, one event per line with stream-json. Claude Code's final object includes total_cost_usd; Antigravity CLI's includes uncached input, cache reads, output and thinking tokens, and the conversation id; Gemini CLI's has a stats block with token usage. Antigravity CLI also has --print-timeout to cap a run's duration, and --mode plan for a read-only pass.
Permission modes, and the silent refusal trap
Without the skip flag, a headless run cannot ask you anything, so a tool that needs approval is denied. We tested it in a container with a prompt that needs a shell command (uname -s > os.txt):
| Exit code | File created | Where the refusal shows | |
|---|---|---|---|
claude -p (no skip flag) |
0 | no |
permission_denials in the JSON; the answer explains the command was not approved |
agy -p (no skip flag) |
0 | no |
denied_actions in the JSON, a notice on stderr, an empty response |
Both exit with code 0. A CI job or cron script that only checks the exit code will report success for a run that did nothing. Check the denial fields, or grant exactly what the job needs: Claude Code's permission modes and allow rules, Antigravity CLI's permissions.allow rules in settings.json, Gemini CLI's --approval-mode (auto_edit approves edits only). Use the full skip flags only in a disposable container or VM, as we did.
Folder trust, sessions and instruction files
-
Folder trust. Gemini CLI refuses to run headless in an untrusted folder ("Gemini CLI is not running in a trusted directory") until you pass
--skip-trustor setGEMINI_CLI_TRUST_WORKSPACE=true, and an untrusted folder does not load its.gemini/settings.json. Antigravity CLI asks "Do you trust the contents of this project?" per folder in interactive mode (trusting a parent does not cover its subfolders), but none of our headless runs was blocked by it. Claude Code asks once per folder in interactive mode and never in-pmode. -
Sessions.
claude --resume <id>,agy --conversation <id>,gemini --resume latest. Claude Code and Gemini CLI also accept a session id chosen in advance (--session-id), which helps when a script needs to find the session again. -
Instruction files. Claude Code reads
CLAUDE.md, Gemini CLIGEMINI.md, Antigravity CLI bothGEMINI.mdandAGENTS.md. For Claude Code and Antigravity CLI, one file is enough: keep your rules inAGENTS.mdand makeCLAUDE.mda one-line import of it,@AGENTS.md.
Which one should you use?
When Claude Code is the better pick
- Anything with a human waiting. It was 9 to 21 times faster on our tasks (median per task).
- Reviews. Same planted bugs found, three extra valid findings per review, the repository left untouched, at half the cost of agy.
- Pay-per-token and scheduled jobs. 3.2x cheaper per task than the default agy setup at API prices.
When Gemini CLI or Antigravity CLI is the better pick
- You already pay for Google AI Pro or Ultra and don't want a second subscription: Antigravity CLI is included, it passed every task, and it can run Claude Opus 5.5 too.
- Work where nobody waits, such as a nightly batch, and your quota has room to spare.
- You need an open-source agent you can audit or fork: that is Gemini CLI on an API key, not Antigravity CLI.
- Your company has Gemini Code Assist Standard or Enterprise: Gemini CLI keeps working as before.
Claude Code vs Gemini CLI vs Codex: the three-way view
| Claude Code | Codex CLI | Antigravity CLI | |
|---|---|---|---|
| Measured on | 2026-10-06 and 2026-10-13 | 2026-10-06 | 2026-10-13 |
| Default model | claude-opus-5-5 | gpt-6.1-sol | gemini-3.8-flash-high |
| Passed | 8/8 both days | 8/8 | 8/8 |
| Cost per passed task | $0.181, then $0.169 | $0.074 | $0.544 |
| Total wall time, 8 runs | 452 s, then 318 s | 389 s | 3,712 s |
Same tasks and checks, but Codex was measured a week earlier, with other CLI versions and 8 parallel runs instead of 4, so compare orders of magnitude, not decimals. On these four tasks, the three are equally correct; Codex is the cheapest, Claude Code the fastest with the deepest reviews, and Antigravity CLI on its default model the slowest and the most expensive at API prices. The details for Codex are in Codex vs Claude Code: Same Tasks, Measured Costs.
Using Gemini and Claude Code together
A recurring suggestion on Hacker News is "Claude plans, Gemini implements". Our numbers point the other way for small tasks, but the idea of splitting work by task type holds: send each step to the agent and model that measured best for it, and let a workflow do the handoff instead of copying text between two terminals.
We ran this benchmark with plain scripts, but in SideHub the same split is a workflow: a list of steps run by an agent on your own machine, where each step can set its own CLI with provider (claude, codex, agy, copilot or gemini). Here is a sketch that implements with Claude Code and asks Antigravity CLI for a second review:
format: sidehub.workflow/v1
name: Implement, then cross-review
defaultProvider: claude
parameters:
- { name: issue, label: Issue number, type: string, required: true }
steps:
- name: Implement the issue
prompt: |
Read GitHub issue #{{inputs.issue}} with `gh issue view`, implement it on a new branch
and run the test suite. Do not push.
- name: Second review
provider: agy
inputsFrom: ["1"]
prompt: |
Review the uncommitted diff of this repository for correctness, edge cases, security and
performance. List each problem with file, line, severity and a reproducing input.
Do not modify any file and do not run commands that write to the repository.
Each step runs as its own run, with its duration, exit code and the token usage read from the Claude Code or Antigravity CLI transcript, and you can follow it from anywhere, phone included. That is how to rerun this comparison on your own codebase and see the cost of each step. The template gallery has workflows to start from: the nightly issue triage and dependency updates are typical unattended jobs where a subscription you already pay for may be the right engine, and the project overview reads a whole repository, the case where a large context window would matter.
Limitations of this benchmark
- Small sample. Two runs per task per CLI, one run for each side measurement.
- One repository, small tasks. A tidy Python library with fast tests. The largest single request was 134k tokens, far from either model's million-token window, so this says nothing about very large codebases.
- Gemini CLI not measured. We had no setup that Gemini CLI accepts for individuals; its numbers on an API key could differ from Antigravity CLI's, even with the same model.
- Default settings only. Default models and effort, no instruction files. Antigravity CLI's default is the High effort of Gemini 3.8 Flash; our single Low run was faster but still 11 times slower than Claude Code.
- Consumer account, shared capacity. Google says Antigravity limits depend on available capacity. We saw no errors, but we cannot rule out slower responses at busy times. The run that went alone took 526 seconds, against 672 seconds for its twin run in parallel.
- Possible contamination. The bug fix comes from a public pull request of 2026-09-16, and two runs (one per CLI) wrote exactly the upstream comparison.
- Dated prices. List prices of 2026-10-13; the Gemini 3.8 Flash price doubles on January 1, 2027.
The verdict
On four everyday tasks, Claude Code (claude-opus-5-5) and Antigravity CLI (gemini-3.8-flash-high) were equally correct: 16 passes out of 16, every planted bug found, no false alarm. Claude Code did it 12 times faster in total and 3.2 times cheaper at API prices, and wrote better reviews. Gemini CLI itself is now an API-key or enterprise tool: if you are an individual, the Google option is Antigravity CLI, and it is worth it mainly if you already pay for Google AI Pro, for work where nobody is waiting, or with a Claude model selected. Whatever you pick, rerun these four tasks on your own repository: the commands, prompts and data are all above.
FAQ
Is Gemini CLI still free in 2026?
Not for personal accounts. Since June 18, 2026, Gemini CLI no longer serves free Gemini Code Assist for individuals, Google AI Pro or Google AI Ultra sign-ins: our run with a Google login failed with "This client is no longer supported for Gemini Code Assist for individuals". It still works with a paid Gemini API key, a Gemini Enterprise Agent Platform key or a Code Assist Standard or Enterprise license.
What replaced Gemini CLI, and is Antigravity CLI the same tool?
Google moved personal accounts to Antigravity CLI, a new binary called agy, written in Go. It keeps Agent Skills, hooks and subagents, turns Gemini CLI extensions into plugins, and still reads GEMINI.md and AGENTS.md, but Google says there is no 1:1 feature parity. Unlike Gemini CLI (Apache 2.0), it is not open source: its GitHub repository holds docs and examples, no source code.
Is Gemini CLI or Antigravity CLI as good as Claude Code for coding?
On correctness, yes in our benchmark: Antigravity CLI with its default model (Gemini 3.8 Flash, High) and Claude Code (Claude Opus 5.5) both passed all four tasks twice and found all three planted bugs in every review. Claude Code gave richer reviews (three extra valid findings per review against one) and respected the read-only review instruction every time; one agy review left a new uv.lock file behind.
Which is cheaper per task, Claude Code or Gemini?
Claude Code, in our runs. At API list prices on 2026-10-13, a passed task cost $0.169 with Claude Code and $0.544 with Antigravity CLI on Gemini 3.8 Flash, 3.2 times more, although Flash tokens are about 5 times cheaper. The default agy setup used about 25 times more input tokens and 14 times more output tokens to do the same work.
Which is faster, Gemini or Claude Code?
Claude Code, by an order of magnitude on our tasks: 318 seconds for all eight runs against 3,712 seconds for Antigravity CLI. The median bug fix took 29 seconds against 10 minutes. 93% of agy's time was spent waiting for the model, and it made 28 to 92 tool calls per task against 2 to 7 for Claude Code.
Can Antigravity CLI run Claude models?
Yes. On our Google AI Pro account, agy models listed Claude Opus 5.5 and Claude Sonnet 5.5 (low, medium and high effort) next to Gemini 3.8 Flash and GPT-OSS 120B. In a single side run, agy with claude-opus-5-5-high fixed the bug in 51 seconds with 7 tool calls, close to Claude Code's 29 seconds, so the slowness we measured comes from the default model, not from the CLI.
How do Claude Pro limits compare with Antigravity quotas on Google AI Pro?
Both are $20-class plans with limits refreshed every five hours plus a weekly cap, and neither publishes a number of messages or tokens. Google says the Gemini Pro and Flash limit is drawn down according to API pricing, so on that basis our default agy runs consumed about 3.2 times more quota value per task than Claude Code's API-equivalent cost. None of our runs hit a limit.
Which one is better for headless, CI and scheduled jobs?
All three have a headless mode (claude -p, gemini -p, agy -p) with JSON output and a flag that skips permission prompts. Claude Code was faster and cheaper on our tasks; agy works with a consumer Google account, Gemini CLI only with an API key or enterprise license. Watch the silent refusal: without the skip flag, claude -p and agy -p deny tools that need approval and still exit 0.
Does Gemini's large context window make a difference on a real repository?
Not on ours. Gemini 3.8 Flash and Claude Opus 5.5 both accept about a million input tokens, and the largest single request we measured was 134k tokens for agy and 33k for Claude Code. The difference was how often each CLI sent its context: agy's 93 model calls on the refactor added up to 6.6 million input tokens.
Should I use both Claude Code and Gemini?
If you already pay for Google AI Pro, Antigravity CLI is a capable second agent for work where nobody waits on the result, and it can also run Claude models from the same subscription. Split by task type, keep shared rules in AGENTS.md so both read them, and measure the cost of each step on your own repository.
Claude Code vs Gemini CLI vs Codex: which is the best AI coding agent right now?
On our four tasks, all three setups we measured were equally correct. Codex (gpt-6.1-sol, measured on 2026-10-06) was the cheapest at $0.074 per passed task, Claude Code was the fastest and gave the deepest reviews, and Antigravity CLI on its default Gemini model was the slowest and, at API prices, the most expensive. Rerun the tasks on your own code before choosing.
Originally published on sidehub.io.
Top comments (0)