Every AI Terminal Tool Compared: Claude Code, Gemini CLI, Codex, Aider, and Eight Others

!Claude Code — AI coding in your terminal

The IDE wars get all the attention. Cursor vs Trae vs Kiro. But the real shift happened quieter: AI agents that live in your terminal, read your entire codebase, run commands, edit files, commit code, and fix their own mistakes, without ever opening a GUI.

I have run real projects through all of them. Some made me ship faster. One cost me $40 in a single afternoon. One was free and outperformed tools I was paying for. Here is what I found. Here is how to set them up properly, including the things the docs do not tell you.

---

The Quick Comparison

---

Claude Code — The Benchmark Everything Else Is Measured Against

Claude Code is Anthropic's terminal agent. Run claude in your project directory. It reads your codebase, you talk to it in natural language, it edits files, runs commands, checks results, and iterates.

87.6% on SWE-bench Verified with Opus 4.7 (Adaptive). 1M token context. The strongest reasoning of any coding agent available. Opus 4.7 shipped April 16, 2026; the default effort level is now xhigh, and the new /ultrareview command produces dedicated code review sessions.

Setup:

# macOS / Linux
curl -fsSL https://claude.ai/install.sh | bash

# Windows
irm https://claude.ai/install.ps1 | iex

# Homebrew
brew install --cask claude-code

# WinGet
winget install Anthropic.ClaudeCode

# Then run it
cd your-project
claude

What works: deepest codebase understanding, hooks for automation, MCP for tool integration, worktrees for parallel subagents, GitHub @claude mentions for PR/issue triage, plugins for custom commands.

What does not: no free tier, locked to Claude models on default auth, Max plan ($100-200/mo) practically required for full-day use. Auto mode (unattended execution) only available on Max plans.

Pricing:

---

Claude Code on AWS Bedrock (BYOK — Skip the Subscription)

Most guides skip this setup. Instead of paying for Claude Pro/Max, you can wire Claude Code directly to AWS Bedrock and pay per token. No subscription. Your AWS account, your billing, your data stays in your VPC.

Why you would do this: - Avoid the $20-200/mo subscription — pay only for what you use - Enterprise compliance: data never leaves your AWS account - Pin specific model versions so updates do not break your workflow - Apply AWS Guardrails for content filtering - Use existing AWS credits or reserved pricing

Step 1 — Enable Claude models in Bedrock

Go to the Bedrock console → Chat/Text playground → select any Anthropic model → fill out the one-time use case form.

Step 2 — Configure AWS credentials

# Option A: AWS CLI (recommended)
aws configure

# Option B: Environment variables
export AWS_ACCESS_KEY_ID=your-access-key-id
export AWS_SECRET_ACCESS_KEY=your-secret-access-key
export AWS_REGION=us-east-1

# Option C: SSO (enterprise)
aws sso login --profile=your-profile
export AWS_PROFILE=your-profile

Step 3 — Point Claude Code at Bedrock

export CLAUDE_CODE_USE_BEDROCK=1
export AWS_REGION=us-east-1

That is it. Claude Code now uses Bedrock instead of Anthropic's API. Authentication goes through your AWS credentials, not a Claude subscription.

Step 4 — Pin model versions (important for teams)

Without pinning, Claude Code may try to use a newer model version that is not available in your Bedrock account. Pin them:

export ANTHROPIC_DEFAULT_OPUS_MODEL='us.anthropic.claude-opus-4-7-v1'
export ANTHROPIC_DEFAULT_SONNET_MODEL='us.anthropic.claude-sonnet-4-6'
export ANTHROPIC_DEFAULT_HAIKU_MODEL='us.anthropic.claude-haiku-4-5-20251001-v1:0'

Step 5 — Auto-refresh SSO credentials

SSO sessions expire after 12 hours. Add this to your Claude Code settings file (~/.claude/settings.json):

{
  "awsAuthRefresh": "aws sso login --profile myprofile",
  "env": {
    "AWS_PROFILE": "myprofile"
  }
}

When credentials expire, Claude Code automatically runs the refresh command before retrying.

Step 6 — Apply Guardrails (optional)

{
  "env": {
    "ANTHROPIC_CUSTOM_HEADERS": "X-Amzn-Bedrock-GuardrailIdentifier: your-guardrail-id\nX-Amzn-Bedrock-GuardrailVersion: 1"
  }
}

IAM policy (minimum required):

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "bedrock:InvokeModel",
        "bedrock:InvokeModelWithResponseStream",
        "bedrock:ListInferenceProfiles"
      ],
      "Resource": [
        "arn:aws:bedrock:<em>:</em>:inference-profile/*",
        "arn:aws:bedrock:<em>:</em>:application-inference-profile/*",
        "arn:aws:bedrock:<em>:</em>:foundation-model/*"
      ]
    }
  ]
}

Bedrock pricing (pay-per-token, no subscription):

Prompt caching multipliers: 5-min cache write 1.25×, 1-hour cache write 2×, cache hit 0.1× base input. For moderate daily use with Sonnet as default: roughly $10-30/month. Significantly cheaper than Pro ($20/mo) when using Haiku for simple tasks and Sonnet for complex ones. Opus 4.7 at $5/$25 per MTok is a major price drop from the old $15/$75 Opus 4.6 pricing.

---

Claude Code on Google Vertex AI

Same concept as Bedrock, different cloud. If your team is on GCP:

export CLAUDE_CODE_USE_VERTEX=1
export CLOUD_ML_REGION=us-east5
export ANTHROPIC_VERTEX_PROJECT_ID=your-project-id

Requires a Google Cloud project with the Vertex AI API enabled and Claude models provisioned.

---

Claude Code Hooks — The Real Power Feature

Hooks are shell commands that run automatically at specific points in Claude's workflow. They turn Claude Code from a chat tool into a programmable agent.

Example: production-grade hooks config

Add to ~/.claude/settings.json:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Edit",
        "command": "node -e \"const f=process.env.TOOL_INPUT_FILE_PATH; if(['.env','package-lock.json','.git'].some(p=>f?.includes(p))){process.exit(1)}\"",
        "description": "Block edits to sensitive files"
      },
      {
        "matcher": "Bash",
        "command": "node -e \"const c=process.env.TOOL_INPUT_COMMAND; if(/rm\\s+-rf|DROP TABLE|truncate/i.test(c)){process.exit(1)}\"",
        "description": "Block destructive commands"
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Edit",
        "command": "npx prettier --write $TOOL_INPUT_FILE_PATH 2>/dev/null || true",
        "description": "Auto-format after every edit"
      },
      {
        "matcher": "Edit",
        "command": "git add $TOOL_INPUT_FILE_PATH",
        "description": "Auto-stage edited files"
      }
    ],
    "SessionStart": [
      {
        "command": "echo \"Node $(node -v) | Git $(git rev-parse --short HEAD) | Branch $(git branch --show-current)\"",
        "description": "Print environment info at session start"
      }
    ]
  }
}

This auto-formats every file Claude edits, auto-stages for git, blocks destructive commands, and protects sensitive files. No manual intervention.

---

Claude Code MCP Servers

MCP (Model Context Protocol) connects Claude Code to external tools: databases, APIs, documentation, project management.

// ~/.claude/settings.json
{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost:5432/mydb"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_TOKEN": "ghp_..." }
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/docs"]
    }
  }
}

Now Claude can query your database, read GitHub issues, and search documentation, all from the terminal.

---

Claude Code on Android (Termux + proot)

Claude Code runs on Android via Termux. It is the same tool, same capabilities, on your phone.

# Install Termux from F-Droid (not Google Play)
pkg update && pkg upgrade
pkg install proot-distro

# Install Ubuntu
proot-distro install ubuntu
proot-distro login ubuntu

# Inside Ubuntu proot
apt update && apt upgrade -y
curl -fsSL https://deb.nodesource.com/setup_24.x | bash -
apt-get install -y nodejs

# Install Claude Code
curl -fsSL https://claude.ai/install.sh | bash

# Run it
claude

Whitelist Termux in battery optimiser. Install Termux:Boot from F-Droid for auto-start on reboot.

---

Claude Code Over Tailscale (Phone → Home Server)

The better setup: run Claude Code on a home server or cloud VM, connect from your phone via Tailscale, use tmux to keep sessions alive.

On your server:

# Install Tailscale
curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up

# Install tmux and mosh (for flaky connections)
sudo apt install -y tmux mosh

# Start a tmux session
tmux new -s claude

# Inside tmux, run Claude Code
cd your-project
claude

On your phone (Termux):

pkg install openssh mosh
# SSH into your server via Tailscale IP
ssh [email protected] -t "tmux attach -t claude"

# Or use mosh for unreliable connections (mobile data)
mosh [email protected] -- tmux attach -t claude

Detach with Ctrl+B, D. Claude keeps running. Reconnect from anywhere. Get notified when it needs input using ntfy:

# On the server, add to your shell
alias claude-notify='claude && curl -s -d "Claude Code finished" ntfy.sh/your-topic'

---

CLAUDE.md — Project-Specific Instructions

Create a CLAUDE.md file in your project root. Claude Code reads it on every session start. Place your project rules here to avoid burning tokens on repeated explanations.

# CLAUDE.md

<h2>Project</h2>
React + TypeScript + Vite + Tailwind + shadcn/ui frontend.
Express + SQLite backend in server/combined.js.

<h2>Rules</h2>
- Run npm test after any code changes
- Use conventional commits (feat:, fix:, chore:)
- Never modify files in /vendor or /dist
- All new pages must be added to KNOWN_PROTECTED_PAGES in server/combined.js
- Use the existing API client at src/lib/api.ts for all fetch calls

<h2>Style</h2>
- TypeScript strict mode
- Tailwind for all styling, no CSS modules
- shadcn/ui components for UI primitives
- No default exports except pages

<h2>Testing</h2>
- Vitest for unit tests
- Test files next to source: foo.test.ts

Nested CLAUDE.md files work too. Put one in server/CLAUDE.md with backend-specific rules.

---

Gemini CLI — 1M Context for Free

Google's Gemini CLI gives you Gemini 2.5 Pro with a 1M token context window. 1,000 requests per day. Free. No credit card. Note: Google announced at I/O 2026 that Gemini CLI's free tier will transition to Antigravity CLI by mid-June 2026, and existing users get 30 days to migrate.

npm install -g @google/gemini-cli
gemini
# Authenticate with your Google account — done

What works: the free tier is absurdly generous. 1M context means it can hold your entire codebase. Multimodal: paste screenshots and it processes them. Deep Google ecosystem integration.

What does not: reasoning quality is a step below Opus 4.7 on ambiguous tasks. No SWE-bench score published. Git integration is basic. No sandboxing. Google Workspace accounts may have restrictions. Future uncertain with Antigravity migration.

Pricing:

Who it is for: anyone who wants to try terminal AI coding without paying anything. The free tier is enough for real work.

---

Codex CLI — The Sandboxed One

OpenAI's open source CLI. Its defining feature: Linux kernel-level sandboxing on by default. When the agent runs code, it runs in an isolated namespace with no network access. If the AI hallucinates rm -rf / or tries to exfiltrate data, it cannot.

npm install -g @openai/codex
codex

What works: strongest isolation of any tool. Open source (MIT). o3 model for complex reasoning. Codex-Mini for 4x throughput on simpler tasks. Cloud mode runs tasks autonomously for up to 30 minutes. GPT-5.3 Codex now scores 85% on SWE-bench Verified.

What does not: requires ChatGPT Plus ($20/mo). Usage limits are confusing. No MCP support. Full sandboxing only on Linux. Moving to usage-based billing.

Pricing:

---

Aider — The Model-Agnostic Veteran

39,000+ GitHub stars. 4.1M installs. 15 billion tokens processed per week. Works with 75+ model providers. The most flexible tool on this list.

pipx install aider-chat

# Use with any model
aider --model claude-3-opus
aider --model deepseek/deepseek-chat
aider --model ollama/llama3
aider --model gemini/gemini-2.5-pro

What works: model-agnostic (switch mid-session), auto-commit every change, watch mode for background monitoring, voice-to-code, works offline with Ollama.

What does not: Python dependency, no built-in model, no sandboxing, interface is functional but not polished.

Cost with different models:

---

OpenCode — The Open Source Claude Code

OpenCode (112,000+ GitHub stars) is the closest open-source equivalent to Claude Code. Built with TypeScript, uses Vercel AI SDK for 75+ model providers, has a proper TUI (terminal UI) built with Bubble Tea, and an HTTP API for remote control.

# Install
curl -fsSL https://opencode.ai/install.sh | bash

# Or via npm
npm install -g opencode

What sets it apart:

- Tab to switch agents — Build agent (full tools) and Plan agent (read-only analysis) are one keystroke away - HTTP API — control it from your phone, a web dashboard, or another script - Persistent sessions — resume where you left off, sessions survive crashes - Desktop app via Tauri for a GUI wrapper around the same engine - 75+ model providers via Vercel AI SDK — same BYO flexibility as Aider but with a better interface

# Run with different models
opencode --model anthropic/claude-sonnet-4-6
opencode --model openai/gpt-5
opencode --model deepseek/deepseek-chat
opencode --model ollama/llama3

Who it is for: developers who want Claude Code's capabilities without the lock-in. Full source available, runs with any model, persistent sessions, and the HTTP API makes remote workflows possible without tmux hacks.

---

Goose — 3,000+ Tools via MCP

Built by Block (Square, Cash App). Free. Open source. Connects to 3,000+ tools through MCP: Jira, GitHub, Slack, databases, CI/CD pipelines.

brew install goose
# or
curl -fsSL https://github.com/block/goose/releases/latest/download/install.sh | bash

What works: massive tool ecosystem through MCP. Recipes for reusable workflows. Model-agnostic. Backed by Block's engineering (not a side project).

What does not: less focused on pure coding than Claude Code or Aider. Overwhelming number of MCP options to configure. No sandboxing.

---

Amp — Parallel Subagents

Sourcegraph's agent. Unique feature: spawns multiple subagents working simultaneously. Ask it to convert 10 files and it runs 3 agents in parallel on different files.

What works: parallel execution on large refactors. Web search fallback when the model does not know something. GitHub integration.

What does not: newer tool, less documentation. Model routing is opaque. Subagents sometimes produce conflicting edits.

---

Cursor CLI — The IDE Agent in Your Terminal

Cursor is primarily an IDE, but it ships a CLI agent too. Run cursor from the terminal and get the same Composer agent that powers the IDE (multi-file editing, model selection, plan mode) without the GUI.

# If Cursor is installed, the CLI is already available
cursor --cli
# Or use the agent directly
cursor agent "refactor the auth module to use JWT"

What works: same deep codebase indexing as the IDE. Switch between Claude, GPT, and Cursor's proprietary model mid-session. Plan mode asks clarifying questions before executing. Cloud agents run tasks asynchronously. OS-level sandboxing added in early 2026.

What does not: requires Cursor subscription ($20/mo minimum). CLI is secondary to the IDE, and feature parity lags. Less documentation than the IDE workflows.

Pricing: same as Cursor IDE — $20/mo Pro, $40/user Teams, $200/mo Ultra for heavy agent use.

---

Copilot CLI — GitHub's Terminal Extension

GitHub Copilot has a CLI mode that provides shell command suggestions and explanations. It is lighter than the other tools here, more of a terminal assistant than a full coding agent.

# Install if you have Copilot
gh extension install github/gh-copilot

# Usage
gh copilot suggest "find all files modified in the last week"
gh copilot explain "git rebase -i HEAD~5"

What works: explains complex commands, suggests shell one-liners, integrates with the gh CLI. Free tier includes it. Useful for sysadmin tasks and learning CLI tools.

What does not: Copilot CLI does not edit files, run multi-step tasks, or understand your codebase. No MCP. No hooks. Limited to command suggestion and explanation.

---

Cline — The Human-in-the-Loop Agent

Cline is an open source VS Code extension and CLI that emphasises human approval at every step. It shows you exactly what it plans to do and waits for your "yes" before executing. The most conservative agent on this list.

# Install as VS Code extension
# Search "Cline" in the marketplace

# Or CLI mode
npx cline

What works: you never lose control: every file edit, every command requires explicit approval. Operates on the live working directory (no snapshot-based context). Model-agnostic. Good for learning what AI agents actually do under the hood.

What does not: the approval flow is slow for large tasks. Not autonomous. You are the bottleneck. Better suited for careful, surgical changes than full project builds.

---

Others Worth Knowing

---

Full Feature Matrix

---

Pricing at a Glance

Cheapest paths:

1. $0 — Gemini CLI + free Google account
2. $0 — Aider/OpenCode + Ollama (local model, limited by hardware)
3. $1-5 — Aider/OpenCode + DeepSeek API
4. $5-10 — Claude Code + Bedrock with Haiku
5. $20 — Claude Code Pro (subscription, simplest setup)

---

Advanced Setups

Mix-and-match: three tools, three use cases

# ~/.bashrc
alias cc="claude"                              # complex reasoning, refactors
alias gc="gemini"                              # quick questions, exploration (free)
alias ai="aider --model deepseek/deepseek-chat" # bulk operations (cheap)

Total: ~$25/mo. Stronger than any single $200 subscription.

Always-on Claude Code on a $5 VPS

# On a Lightsail $5/mo instance
curl -fsSL https://claude.ai/install.sh | bash
sudo apt install -y tmux

# Create a persistent session
tmux new -s work
claude

# Connect from anywhere via Tailscale
# On your laptop/phone:
ssh [email protected] -t "tmux attach -t work"

Claude Code as a CI agent

Wire Claude Code into GitHub Actions to triage issues and review PRs:

# .github/workflows/claude-review.yml
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: curl -fsSL https://claude.ai/install.sh | bash
      - run: |
          export ANTHROPIC_API_KEY=${{ secrets.ANTHROPIC_API_KEY }}
          claude "Review this PR for bugs, security issues, and style violations. Be concise."

Build your own Claude Code

If you want full control, OpenCode and Aider are both open source and extensible:

OpenCode approach (TypeScript, Vercel AI SDK):

git clone https://github.com/anomalyco/opencode
cd opencode
npm install
npm run dev
# Modify packages/core/ for custom agent behavior
# Modify packages/tui/ for custom UI
# The HTTP API at packages/web/ lets you build any frontend

Aider approach (Python, model-agnostic):

git clone https://github.com/paul-gauthier/aider
cd aider
pip install -e .
# Modify aider/coders/ for custom coding strategies
# Modify aider/models/ to add new providers

From scratch with Claude Agent SDK:

npm install claude-agent-sdk

import { Agent } from 'claude-agent-sdk';

const agent = new Agent({
  model: 'claude-sonnet-4-6',
  tools: [
    { name: 'read_file', /<em> ... </em>/ },
    { name: 'write_file', /<em> ... </em>/ },
    { name: 'bash', /<em> ... </em>/ },
  ],
});

const result = await agent.run('Fix the failing tests in src/lib/');

The Claude Agent SDK gives you the same agentic loop that Claude Code uses (tool selection, execution, result evaluation, retry) as a library you can embed in your own tools.

---

How to Choose

Strongest reasoning, willing to pay: Claude Code. Nothing else has Opus 4.7 at 1M context with 87.6% SWE-bench. The new $5/$25 per MTok pricing on Bedrock makes it significantly cheaper than before.

Strongest reasoning, want to control costs: Claude Code on Bedrock. Pay per token. Use Haiku for simple tasks, Sonnet for complex, Opus for critical. Typical $10-30/mo vs $20-200/mo subscription. Opus 4.7's price drop (from $15/$75 to $5/$25 per MTok) makes the BYOK path even more attractive.

Free and capable: Gemini CLI. 1M context, 60 req/min. Start here.

Strongest security: Codex CLI. Kernel-level sandboxing by default. The agent cannot access your network or filesystem outside the sandbox.

Maximum model flexibility, minimum lock-in: Aider or OpenCode. 75+ providers. Run Claude, GPT, Gemini, DeepSeek, or local Ollama. Switch mid-session.

AI needs to do more than code (databases, APIs, project management): Goose. 3,000+ MCP tools.

Working on a team, need parallel execution: Amp. Subagents working simultaneously on different files.

Want to build your own tool: OpenCode (TypeScript) or Aider (Python). Fork, modify, deploy.

Running from a phone or remote: Claude Code + Tailscale + tmux on a home server. Or Claude Code on Termux proot for fully local Android.

---

The terminal tools are better than IDE tools at understanding your full project, running commands, and iterating autonomously. The IDE tools are better at visual diffs, inline completion, and editing flow. Use both. Start a task with Claude Code or Gemini CLI, switch to your IDE for fine-tuning.

None of these require annual contracts. Try Gemini CLI for free today. If you need more, upgrade to Claude Code or wire up Bedrock. The market will consolidate, but right now the best strategy is the cheapest one that does not slow you down.

---

- Claude Code — Install - Claude Code Docs — Bedrock setup - Claude Code Docs — Hooks - Claude Code Docs — MCP - Gemini CLI - Codex CLI — GitHub - Aider - OpenCode — GitHub - Goose — GitHub - Amp — Sourcegraph - Claude Agent SDK

---

Last updated: May 21, 2026