Codex CLI vs Claude Code vs Gemini CLI: how to choose

Quick answer: three different jobs, not one winner.

Codex CLI, Claude Code, and Gemini CLI all do the same basic thing: they sit in your terminal, read your repository, and edit files or run commands on your instruction. The difference is in the defaults each vendor picked and what that means for your workflow and your bill. Claude Code, built by Anthropic, defaults to a Claude Sonnet-tier model with an Opus override for the hardest tasks, and it is widely reported as the strongest of the three at tracing a bug across multiple files and at refactors that touch tests as well as source. Codex CLI, built by OpenAI, runs a GPT-5-family coding model inside an OS-level sandbox by default, with Docker available as an opt-in for stricter isolation, which makes it a safe pick for unattended runs in CI. Gemini CLI, built by Google, defaults to a Google account login but also accepts a GEMINI_API_KEY or Vertex AI credential, defaults to a Gemini model with a very large context window, and is free to use inside a daily request quota rather than billed per token on that default login path. None of the three is a strict upgrade over the others. The rest of this page works through the mechanics, the real cost math, and the setup for each so you can match the tool to the job instead of guessing from a marketing page.

How each CLI actually works, and where the bill comes from.

That last point is what actually drives the bill for Codex CLI and Claude Code. Both are metered per token against whatever account you authenticate with, and because each call in the loop resends the growing context, a single multi-step task can burn far more tokens than the length of your original prompt would suggest. Gemini CLI sidesteps this arithmetic for most users: it runs against a free daily quota tied to your Google account, so the practical limit is a wait for the quota to reset rather than a running dollar total, at least until you exceed what the free tier allows.

• Codex CLI talks to an OpenAI-compatible chat completions endpoint, defaults to a GPT-5-family coding model, and executes shell commands and file edits inside an OS-level sandbox (seatbelt on macOS, landlock on Linux) that isolates network access unless you open it up; Docker is an opt-in, not the default.
• Claude Code talks to the Anthropic Messages API, defaults to a Claude Sonnet-tier model with an Opus override for architecture and hard debugging, and runs commands through a restricted local shell that still prompts before most writes.
• Gemini CLI defaults to a Google account login but also supports a GEMINI_API_KEY or Vertex AI credential, defaults to a Gemini model with the largest context window of the three, and does not wrap file writes or shell execution in the same kind of sandbox the other two use.
• All three are agentic, not single shot. One instruction from you can become a dozen or more model calls as the tool reads files, runs a command, checks the result, and decides what to do next, and every one of those calls resends the conversation built up so far.

Worked example: what a real coding session costs.

Model this by call volume instead of guessing. A short session might run about 8 agent calls, a typical session runs closer to 30, and a heavy day of three long sessions can push past 90. Because each call resends the accumulated context, tokens climb faster than call count: the table below assumes roughly 0.4M input tokens for a light session, 2.4M for a typical one, and 9M across a heavy day, with output staying small in every case. Codex CLI is priced here at OpenAI's direct list rate for a GPT-5-family coding model in this site's catalog, gpt-5.3-codex-spark, and Claude Code at Anthropic's direct list rate for claude-sonnet-4-6. Gemini CLI has no per-token bill for most users because it runs against a free daily quota, so its column reads as free until that quota resets rather than a dollar figure.

Why the bill, or the quota, surprises people.

Most of this is avoidable with a bit of routing discipline, which the next two sections cover.

• Free is not unlimited. Gemini CLI's no-cost tier still enforces a daily request cap on your Google account, and hitting it mid-task stops the session rather than a meter running up.
• Agent loops multiply calls fast. A single request to fix a failing test can trigger far more model calls than the one message you typed, and each call re-bills the context that came before it.
• Sandboxing adds latency, not just isolation. Codex CLI's default OS-level sandbox adds a little startup overhead per session that a plain restricted shell skips, and opting into full Docker isolation for CI adds more still, which shows up as slower turnaround rather than a bigger bill.
• Swapping the default model changes the bill without changing the workflow. Pointing any of these tools at the priciest tier for routine edits multiplies cost for work a cheaper model handles just as well.
• CI and other non-interactive runs remove the approval prompts that normally let you notice a runaway loop before it finishes, so the first sign of trouble is often the invoice or the exhausted quota, not a warning on screen.

Codex CLI vs Claude Code vs Gemini CLI, feature by feature.

The three tools converge on the basics: reading a repository, editing files, running commands. They diverge on sandboxing, billing, and how you authenticate. Treat the table below as a practical summary, not a spec sheet; every vendor updates the underlying model on its own schedule.

Practical ways to keep the cost down.

APIsRouter is one such gateway: an OpenAI-compatible and Anthropic-compatible API with pay-as-you-go billing and no subscription. Global models are priced 20% below their official list rate, Chinese models sit below their own official rates, the first top-up adds a 100% balance bonus, and the /topup checkout takes payment first and emails the key with no signup form. The table below lines up the models used in the worked example above against their official rate and their price through a gateway like this.

• Match the model to the task. Keep an Opus-tier or top GPT-5 variant for architecture calls and hard bugs, and default routine edits, boilerplate, and test scaffolding to a cheaper model in the same family.
• Cap the loop. Scope a Codex CLI or Claude Code task narrowly instead of turning it loose on the whole repository; a tighter prompt means fewer exploratory calls before it reports back.
• Watch the quota, not just the clock, on Gemini CLI. Heavy multi-file analysis burns through a daily cap fast, and there is no pay-as-you-go fallback inside the free tier.
• Use non-interactive mode deliberately. Claude Code's scripting flag and Codex CLI's sandboxed exec mode are built for CI, but skip the manual approval step, so keep task scope tight specifically there.
• Route routine traffic through a cheaper OpenAI-compatible gateway. Both Codex CLI and Claude Code read their endpoint from an environment variable, so pointing that variable at a lower-cost gateway lowers the per-token rate for the same workflow without touching a single prompt.

Install each CLI, then point it at a cheaper endpoint.

All three tools install the same way, through npm, and each reads its credentials from a different place. Codex CLI reads OPENAI_API_KEY and an optional OPENAI_BASE_URL. Claude Code reads ANTHROPIC_API_KEY and an optional ANTHROPIC_BASE_URL, or the matching fields in ~/.claude/settings.json. Gemini CLI reads neither by default; it authenticates through a Google account login on first launch, or through a GEMINI_API_KEY or Vertex AI credential, but none of those give it a custom base URL. That last point matters for routing. Only Codex CLI and Claude Code can be repointed at a different OpenAI-compatible or Anthropic-compatible endpoint; Gemini CLI cannot. Verify a new key with a single short request before pointing a full day of work at it.

# Codex CLI
npm install -g @openai/codex
export OPENAI_API_KEY="sk-your-openai-key"
# Or point at an OpenAI-compatible endpoint instead of OpenAI directly:
# export OPENAI_API_KEY="sk-APIsRouter-..."
# export OPENAI_BASE_URL="https://api.apisrouter.com/v1"
codex

# Claude Code
npm install -g @anthropic-ai/claude-code
export ANTHROPIC_API_KEY="sk-ant-your-key"
claude

# Gemini CLI (auth is chosen interactively on first launch: Google account, API key, or Vertex AI; no endpoint override)
npm install -g @google/gemini-cli
gemini

FAQ