Terminal AI coding agents now do more than suggest shell commands. They can inspect repositories, edit files, run tests, call external tools, and delegate work. The important differences are not the chat interface or benchmark headline. They are the controls around execution: parallelism, sandboxing, Model Context Protocol (MCP) support, lifecycle hooks, and the ability to keep risky work bounded.
This comparison covers Claude Code, OpenAI Codex CLI, Gemini CLI, and GitHub Copilot CLI. Capabilities and specifications are as of 2026-07-20 and can change, especially where official documentation marks a feature as preview or experimental.
Capability matrix
| CLI agent | Parallel work | Sandboxing | MCP | Hooks |
|---|---|---|---|---|
| Claude Code | Background subagents, agent view, experimental agent teams, worktrees, and batch workflows | OS-level filesystem and network restrictions; optional hard failure if unavailable | Yes, including scoped server configuration and MCP tool hooks | Extensive lifecycle events with command, HTTP, MCP-tool, prompt, and experimental agent handlers |
| OpenAI Codex CLI | Subagent workflows can delegate independent work and combine results | OS-enforced local sandbox; read-only and workspace-write modes; network off by default | Yes, for external tools and context providers | Project or user hooks via hooks.json or config.toml |
| Gemini CLI | Specialized subagents with independent contexts; worktree launch support is available | Optional macOS Seatbelt, Docker/Podman, gVisor, native Windows, and tool-level sandboxing | Yes, including subagent-scoped MCP servers | Lifecycle hooks managed through /hooks |
| GitHub Copilot CLI | /fleet can split a task across subagents and run independent work in parallel | Local and cloud sandboxes are available in public preview | Yes, with tool search to reduce context overhead | Yes, with repository, organization, and enterprise configuration scopes |
The table says whether a control exists, not whether every operating system, account, or release exposes it identically. Confirm your installed version and organization policy before designing automation around a feature.
Claude Code: the broadest orchestration vocabulary
Claude Code documents several distinct ways to parallelize: subagents inside a session, an agent view for background sessions, experimental agent teams with shared coordination, isolated worktrees, and /batch for larger planned splits. Anthropic’s parallel agents guide explicitly distinguishes these modes and warns that concurrent workers multiply token usage.
Its sandbox is not merely a confirmation prompt. Anthropic describes OS-level filesystem and network restrictions, write access limited to the current working directory by default, and an optional sandbox.failIfUnavailable setting for managed deployments that must fail closed (sandboxing documentation). The default fallback deserves attention: without hard-fail configuration, Claude Code can warn and continue unsandboxed if the sandbox cannot start.
Claude Code supports MCP for connecting external tools and data (MCP documentation). Its hook system is unusually broad: official docs list command, HTTP, MCP-tool, prompt, and experimental agent hook types across lifecycle events (hooks reference). That makes it suitable for mandatory formatters, policy checks, telemetry, or post-edit verification, but a hook is only as safe as the script or endpoint it invokes.
Best fit: teams that want several orchestration patterns and detailed lifecycle customization. Main caution: agent teams are experimental, parallelism raises consumption, and sandbox fallback should be configured deliberately.
OpenAI Codex CLI: strong local boundaries and integrated delegation
Codex CLI uses two separate controls: the sandbox defines what commands can technically access, while the approval policy defines when the agent must stop. OpenAI says local Codex defaults to no network access and write permissions limited to the active workspace. Read-only and workspace-write modes are available, and the sandbox is enforced with operating-system mechanisms (agent approvals and security).
Current Codex releases support subagent workflows in the CLI. A main thread can delegate independent tasks, show agent threads through /agent, and combine results. OpenAI cautions that each subagent performs separate model and tool work, so parallel execution consumes more tokens than a comparable single-agent run (subagents documentation).
Codex uses MCP as a standard integration layer for tools and shared context (customization guide). It also supports lifecycle hooks in user or trusted project configuration, either through hooks.json or inline config.toml tables (advanced configuration). Project-local hooks are ignored when the project is untrusted, which is a useful boundary when opening unfamiliar repositories.
Best fit: local repository work where explicit filesystem, network, and approval boundaries are central. Main caution: adding MCP tools and subagents expands both trust surface and token use; least-privilege configuration still matters.
Gemini CLI: open-source flexibility and multiple sandbox backends
Gemini CLI’s official repository documents specialized subagents with separate context loops and restricted tool sets. Subagents may receive their own inline MCP server definitions, and recursion protection prevents them from spawning more subagents (subagents documentation). The CLI also has an experimental worktree launch option, but the documented subagent page does not promise that every delegation will run concurrently. Treat concurrency as workflow-dependent rather than automatic.
Access changed shortly before this comparison. Google says Gemini CLI stopped serving requests for Gemini Code Assist for individuals, Google AI Pro, and Google AI Ultra on June 18, 2026. Current use can come through Gemini Code Assist Standard or Enterprise quotas, or through a Gemini API key with pay-as-you-go billing (Gemini CLI documentation). Verify authentication and billing before treating the open-source client itself as a free service.
Sandbox choice is Gemini CLI’s distinctive strength. The project documents macOS Seatbelt profiles, Docker or Podman containers, gVisor on Linux, a native Windows sandbox, and granular tool-level sandboxing. Sandboxing is optional and can be enabled by flag, environment variable, or settings file (sandbox guide).
MCP servers can extend the tool registry, and /mcp manages discovery and authentication. The command reference also exposes /hooks for enabling, disabling, listing, and inspecting lifecycle hooks (command reference).
Best fit: developers who want an open-source CLI and a choice of isolation backends. Main caution: optional controls must be enabled and tested; the strongest container or gVisor setup carries more operational overhead than a lightweight local mode.
GitHub Copilot CLI: GitHub-native workflows and fleet execution
GitHub Copilot CLI is available across Copilot plans and can answer questions, edit and debug code, and interact with GitHub.com. GitHub documents local and cloud sandboxes in public preview. Local sandboxing can restrict filesystem, network, and system capabilities, while cloud sandboxes provide isolated hosted environments and can retain session state (Copilot CLI overview).
For parallelism, /fleet lets an orchestrator split a larger request into subagents. GitHub says independent subagents can run in parallel and each receives a separate context window. Fleet activity consumes GitHub AI Credits, so speed can increase spend (fleet documentation).
Copilot CLI can connect MCP servers, and GitHub’s tool-search feature loads tools on demand to reduce the context cost of large tool catalogs (tool search documentation). GitHub also documents hooks for Copilot CLI and cloud agents (hooks documentation).
Best fit: teams whose issues, pull requests, policies, and reviews already live in GitHub. Main caution: sandbox features are preview as of 2026-07-20, and agent operations draw from the same AI-credit system used by other Copilot features.
How to choose
Choose by the failure you most need to prevent.
- If uncontrolled filesystem or network access is the main risk, compare the exact sandbox default on your operating system and test a denied write plus a denied network call.
- If a repository-wide migration is the goal, compare worktree isolation, concurrent-worker limits, and how each product reconciles edits.
- If external tools are essential, inventory MCP authentication, tool scoping, and whether a compromised server could mutate production systems.
- If policy must be automatic, inspect hook events, failure behavior, timeout handling, and whether project-local hooks require trust.
- If budget predictability matters, measure the same tasks with one agent and with parallel delegation. Faster wall-clock time is not automatically cheaper.
A neutral evaluation script
Run the same five tasks in a disposable repository for each CLI:
- Read the project and explain one execution path without editing.
- Make a small change and run a focused test.
- Attempt a write outside the workspace and confirm it is blocked or requires approval.
- Connect one read-only MCP server and inspect the tool list.
- Split a read-heavy audit into three independent tasks and record elapsed time, tokens or credits, and result quality.
Score successful test completion, unauthorized actions, changed-file accuracy, operator interruptions, and total metered usage. Do not score prose confidence. The best terminal agent is the one whose controls match the repository’s risk and whose verified output justifies its cost.
Bottom line
Claude Code currently exposes the widest named set of parallel workflow styles. Codex CLI emphasizes an integrated OS sandbox, approval policy, and delegated subagents. Gemini CLI offers the broadest documented choice of sandbox backends. GitHub Copilot CLI connects fleet-style work to GitHub-native workflows and credit billing.
All four support MCP and hooks in some form as of 2026-07-20. The meaningful differences are defaults, trust boundaries, maturity, and failure behavior. Recheck the official documentation after upgrades because several capabilities are still evolving.