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

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.md and AGENTS.md in your project are read as before.
• Workspace skills move from .gemini/skills/ to .agents/skills/.
• MCP servers move from ~/.gemini/settings.json to ~/.gemini/config/mcp_config.json (or .agents/mcp_config.json in a project).
• agy plugin import gemini converts 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:

1. 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.
2. 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.

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 result event (uncached input, cache writes, cache reads, output including thinking) and Antigravity CLI's result event (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

Bug fix from a real issue

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

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

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

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 OverflowError where the docstring promises ValueError, GNU-style sizes such as 2.9M (which naturalsize(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 ran uv run ruff check . to lint the code, and uv run created a 415-line uv.lock in 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

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:

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:

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):

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-trust or set GEMINI_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 -p mode.
• Sessions. claude --resume , agy --conversation , 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 CLI GEMINI.md, Antigravity CLI both GEMINI.md and AGENTS.md. For Claude Code and Antigravity CLI, one file is enough: keep your rules in AGENTS.md and make CLAUDE.md a 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

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.