Claude Code and Other Coding Agents

What this appendix is

This course teaches with Claude Code. Three other coding agents run in the terminal on the same agent loop (Chapter 1): OpenAI’s Codex, GitHub’s Copilot CLI, and Google’s Antigravity CLI (which replaced Gemini CLI for individual users on June 18, 2026). The model and the harness differ, so the commands, file names, and safety controls differ too. This appendix maps each Claude Code concept the book teaches to its counterpart in the other three, so that what you learn here works whichever agent your team or employer uses.

The tables come first: what each tool costs, a score for how much harness each one has, then features, files, every command, every tool the agent can call, and keys. After them, one section per tool covers the differences that change what you do.

All four tools change every few weeks. Every cell was checked against the vendors’ documentation on October 10, 2026: Claude Code, Codex, Copilot CLI, and Antigravity CLI. “Not listed” means the reference does not mention it, which is different from “does not exist.” When a cell and the current docs disagree, the docs are right.

The concepts transfer

Everything in Chapter 2 is a property of agents, so none of it is specific to Claude. The agent knows only what is in its context window. A standing rule belongs in a file the agent re-reads every session. A procedure you repeat belongs in a skill. Advice in an instruction file can be ignored; a rule or hook that sits between the model and the tool cannot. An action’s blast radius decides how much you let the agent do without you. The tables below change only the names.

Which one can you use?

	Claude Code	Codex	Copilot CLI	Antigravity CLI
Sign in with	Claude account	ChatGPT account	GitHub account	Google account
Free option	None; needs Pro, Max, Team, or Enterprise, or an API key	ChatGPT Free (pricing)	Copilot Free, and Copilot Student for verified students (plans)	Personal Google account, with a weekly quota (plans)
Can it use Claude models?	Yes	No	Yes, on paid plans; Free and Student pick the model for you	Yes, on Google AI Pro (paid), Ultra, and Enterprise (models)
Company billing	Claude Team or Enterprise, or Google Cloud or Microsoft Foundry	ChatGPT Business or Enterprise	GitHub Copilot Business or Enterprise	Gemini Enterprise

No Claude plan? Copilot Student is the closest free substitute for this course. It is a terminal agent built around GitHub, and it reads your CLAUDE.md and .claude/skills/ without changes (see Using one repo with all four). A Claude model inside another tool is still not Claude Code: you get the model, in that tool’s harness.

How much harness does each one have?

The model is only part of an agent. The harness around it builds each request, checks each tool call, runs the tools, and manages the context window (The model and the harness). To compare the four harnesses, we scored each against a checklist of 35 capabilities, grouped under those jobs. Each item is a yes or no taken from the tables on this page. A blank cell means the tool’s documentation does not describe it.

Harness job	Items	Claude Code	Codex	Copilot CLI	Antigravity CLI
Build the request	6	6	4	6	5
Manage the context window	3	3	1	2	1
Check the call	7	7	6	4	5
Run the tools	4	4	2	4	3
Recover	3	2	1	3	1
Delegate	4	4	1	4	1
Reach beyond your laptop	5	5	5	5	4
Run from scripts	3	3	3	2	3
Total	35	34	23	30	23
Commands inside a session		111	50	77	37
Built-in tools named in the docs		46	6	23	22

What the scores show:

Claude Code has the most complete harness here: every item but one, and the most commands and tools. The one it misses, undo that also reverses shell commands, is one Copilot CLI has.
Copilot CLI scores second, four items behind. It is weakest at checking calls: it has no rules file you can commit, so a rule has to be passed at launch or written as a hook. It is strongest at recovery, with an undo that restores files changed by shell commands too.
Codex and Antigravity CLI tie. Codex is strong at enforcement (sandbox on by default, rules, a reviewer model) and weak at recovery, delegation, and context management (no file undo, no worktrees, no view of what fills the window). Antigravity is strong at instructions and permission rules, and weak in the same three places.
The gaps that matter most for this course are in Recover. Without a file undo, every edit the agent makes falls in group 2 of Blast Radius: commit before you start.

How to read this score, and the full checklist

This is our own checklist, not a published benchmark. Read it with three limits in mind:

It counts capabilities, not quality. A yes says a feature exists. It says nothing about how well it works, how reliable the agent is, or how good the model is. A tool with a lower score and a stronger model can still produce better work.
It favors Claude Code. The checklist comes from what this book teaches, and the book teaches with Claude Code, so Claude Code’s features set the list. An item another tool has and Claude Code lacks gets in only if it fits a harness job, such as Copilot’s shell-command undo.
It depends on the documentation. Codex has no tools reference, so its tool count (6) counts only the tools its hooks page names; the real number is likely higher. A blank cell means “not documented,” not “impossible.”

The counts were taken on October 10, 2026, from the same sources as the tables. Each job has a different number of items, so compare tools within a row before comparing totals.

Build the request

Item	Claude Code	Codex	Copilot CLI	Antigravity CLI
Reads `AGENTS.md`	Yes	Yes	Yes	Yes
Instruction files in subfolders	Yes	Yes	Yes	Yes
Rules scoped to file patterns	Yes		Yes	Yes
Instruction files can import other files	Yes		Yes	Yes
Skills that load only when needed	Yes	Yes	Yes	Yes
Memory the agent writes itself	Yes	Yes	Yes

Manage the context window

Item	Claude Code	Codex	Copilot CLI	Antigravity CLI
Shows what fills the window	Yes		Yes	Yes
Summarize on demand (`/compact`)	Yes	Yes	Yes
Set when automatic compaction starts	Yes

Check the call

Item	Claude Code	Codex	Copilot CLI	Antigravity CLI
Switch permission modes during a session	Yes	Yes	Yes	Yes
Saved allow, ask, and deny rules	Yes	Yes		Yes
Rules you can commit with the project	Yes	Yes
Operating-system sandbox for shell commands	Yes	Yes	Yes	Yes
Hooks that can block a tool call	Yes	Yes	Yes	Yes
Hooks that can ask you instead	Yes		Yes	Yes
A reviewer model that approves routine actions	Yes	Yes

Run the tools

Item	Claude Code	Codex	Copilot CLI	Antigravity CLI
Fetch a web page	Yes		Yes	Yes
Search the web	Yes	Yes	Yes	Yes
Code intelligence from a language server	Yes		Yes
Long-running shell commands it can check on	Yes	Yes	Yes	Yes

Recover

Item	Claude Code	Codex	Copilot CLI	Antigravity CLI
Undo restores files	Yes		Yes
Undo also reverses shell commands			Yes
Copy the conversation to try another direction	Yes	Yes	Yes	Yes

Delegate

Item	Claude Code	Codex	Copilot CLI	Antigravity CLI
Subagents you define in files	Yes	Yes	Yes
Built-in git worktrees	Yes		Yes
A command that splits work across parallel agents	Yes		Yes	Yes
Several sessions running at once	Yes		Yes

Reach beyond your laptop

Item	Claude Code	Codex	Copilot CLI	Antigravity CLI
MCP servers	Yes	Yes	Yes	Yes
Plugins and marketplaces	Yes	Yes	Yes	Yes
Run the session in the cloud	Yes	Yes	Yes
Control the session from another device	Yes	Yes	Yes	Yes
Hand the session to a desktop app	Yes	Yes	Yes	Yes

Run from scripts

Item	Claude Code	Codex	Copilot CLI	Antigravity CLI
One-shot prompt	Yes	Yes	Yes	Yes
JSON or streaming output	Yes	Yes	Yes	Yes
Output checked against a schema you supply	Yes	Yes		Yes

Features

What it is	Claude Code	Codex	Copilot CLI	Antigravity CLI
Start a session	`claude`	`codex`	`copilot`	`agy`
Project instruction file	`CLAUDE.md`	`AGENTS.md`	`AGENTS.md`, `CLAUDE.md`, `GEMINI.md`, `.github/copilot-instructions.md` (all combined)	`AGENTS.md`, `GEMINI.md`
Skills (a `SKILL.md` folder)	Yes	Yes	Yes	Yes
Run a skill by name	`/skill-name`	`$skill-name`	`/skill-name`	`/skill-name`
Plan before editing	Plan mode	`/plan`	Plan mode	Plan mode
Approval presets	Manual, Accept edits, Plan, Auto, Bypass	Read Only, Auto, Full Access	Standard, plan, autopilot; `/permissions` sets default, assisted, or allow-all	default, accept-edits, plan
Saved allow, ask, and deny rules	`permissions` in `settings.json`	`prefix_rule` in a `.rules` file (experimental)	Not as a file; `--allow-tool` and `--deny-tool` at launch, or a hook	`allow`, `ask`, `deny` lists in `~/.gemini/antigravity-cli/settings.json`
Sandbox for shell commands	Off by default; `/sandbox`	On by default	Off by default; `/sandbox enable`	Off by default; `enableTerminalSandbox`
Hooks	Yes	Yes; must be trusted in `/hooks`	Yes	Yes
Undo the agent’s file edits	`/rewind` (its own edits, not shell commands)	None; use git	`/undo`, “Conversation + files” (edits and shell commands)	`/rewind` restores the conversation; files not documented, so use git
Subagents	Yes; define your own	Yes; define your own	Yes; define custom agents	Yes; the main agent starts them
Memory the agent writes itself	On by default	Off by default	Copilot Memory, stored by GitHub	Not documented
MCP servers	Yes	Yes	Yes	Yes
Run one prompt from a script	`claude -p`	`codex exec`	`copilot -p`	`agy -p`
Separate copy of the files (git worktree)	`claude -w`	Not listed for the CLI	`copilot -w`, `/worktree`	Not listed for the CLI
Run in the cloud	`claude --cloud`	`codex cloud`	`copilot --cloud` (preview), `/delegate`	Not listed for the CLI
Desktop app	Claude desktop app, `/desktop` (compared)	ChatGPT desktop app, `/app` (compared)	GitHub Copilot app, `/app`	Antigravity 2.0

Files and folders

“Project” files live in your repo and are committed; “you” files live in your home folder and apply to every project.

What	Claude Code	Codex	Copilot CLI	Antigravity CLI
Instructions, project	`CLAUDE.md`, `.claude/rules/`	`AGENTS.md`	`AGENTS.md`, `CLAUDE.md`, `.github/copilot-instructions.md`, `.claude/rules/`	`AGENTS.md`, `GEMINI.md`, `.agents/rules/`
Instructions, you	`~/.claude/CLAUDE.md`	`~/.codex/AGENTS.md`	`~/.copilot/copilot-instructions.md`	`~/.gemini/AGENTS.md`
Skills, project	`.claude/skills/`	`.agents/skills/`	`.github/skills/`, `.claude/skills/`, `.agents/skills/`	`.agents/skills/`
Skills, you	`~/.claude/skills/`	`~/.agents/skills/`	`~/.copilot/skills/`, `~/.agents/skills/`	`~/.gemini/antigravity-cli/skills/`
Settings, project	`.claude/settings.json`	`.codex/config.toml`	`.github/copilot/settings.json`	Not listed
Settings, you	`~/.claude/settings.json`	`~/.codex/config.toml`	`~/.copilot/settings.json`	`~/.gemini/antigravity-cli/settings.json`
Hooks, project	`hooks` in `.claude/settings.json`	`.codex/hooks.json`	`.github/hooks/*.json`, also reads `.claude/settings.json`	`.agents/hooks.json`
MCP servers, project	`.mcp.json`	`.codex/config.toml`	`.mcp.json`	`.agents/mcp_config.json`
MCP servers, you	`~/.claude.json`	`~/.codex/config.toml`	`~/.copilot/mcp-config.json`	`~/.gemini/config/mcp_config.json`
Subagents, project	`.claude/agents/`	`.codex/agents/` (TOML)	`.github/agents/`	Not defined in files

Commands

Every command the four references list, grouped by what it does. Aliases are in parentheses. A blank cell means that tool’s reference lists no command for it; the tool may still do it another way (Codex sets effort inside /model, for example). Commands that work only in a desktop app, an IDE extension, or a cloud product are left out, and so are commands marked removed.

In your shell

What it does	Claude Code	Codex	Copilot CLI	Antigravity CLI
Install (macOS)	install script (setup)	install script (Codex CLI)	`brew install --cask copilot-cli`	install script (getting started)
Install (any OS, with Node)	`npm install -g @anthropic-ai/claude-code`	`npm install -g @openai/codex`	`npm install -g @github/copilot`
Start a session	`claude`	`codex`	`copilot`	`agy`
Start a session with a first prompt	`claude "..."`		`copilot -i "..."`
Run one prompt and exit	`claude -p`	`codex exec` (`codex e`)	`copilot -p`	`agy -p`
Continue the last session	`claude -c`	`codex resume --last`	`copilot --continue`	`agy -c`
Pick a past session	`claude -r`	`codex resume`	`copilot --resume`	`agy --conversation <id>`
Copy a past session into a new one	`claude -r <id> --fork-session`	`codex fork`
Choose a mode at launch	`claude --permission-mode`	`codex --sandbox`, `--ask-for-approval`	`copilot --mode`	`agy --mode`
Update	`claude update`	`codex update`	`copilot update`	`agy update`
Install a specific version	`claude install`
Version	`claude -v`		`copilot version`	`agy --version`
Help	`claude --help`		`copilot help`	`agy --help`
Sign in	`claude auth login`	`codex login`	`copilot login`
Sign out	`claude auth logout`	`codex logout`
Check sign-in	`claude auth status`	`codex login status`
Token for scripts and CI	`claude setup-token`
Diagnose the installation	`claude doctor`	`codex doctor`
Read or change settings			`copilot config`
Feature flags		`codex features`
Write starter instructions			`copilot init`
List instruction files found			`copilot instruction`
MCP servers	`claude mcp`	`codex mcp`	`copilot mcp`
Plugins and marketplaces	`claude plugin`	`codex plugin`, `codex plugin marketplace`	`copilot plugin`	`agy plugin`
Skills			`copilot skill`
Language servers			`copilot lsp`
Import another tool’s setup	`claude import`			`agy plugin import gemini`
Code review without a session	`claude ultrareview`	`codex review`
Run in the cloud	`claude --cloud`	`codex cloud`	`copilot --cloud`
Bring cloud work to your laptop	`claude --teleport`	`codex apply`
Open the desktop app	`claude --desktop`	`codex app`	`copilot app`
Remote control from another device	`claude remote-control`	`codex remote-control`	`copilot --remote`	`agy remote-control`
Background sessions	`claude --bg`, `claude agents`, `attach`, `logs`, `respawn`, `stop`, `rm`
Background session service	`claude daemon`
List models		`codex debug models`		`agy models`
List agents				`agy agents`
Archive or delete saved sessions	`claude purge`	`codex archive`, `unarchive`, `delete`
Shell tab completion		`codex completion`	`copilot completion`
Run a command in the sandbox		`codex sandbox`
Sandbox certificate			`copilot sandbox ca`
Test a rules file		`codex execpolicy`
Auto mode rules	`claude auto-mode`
Run a saved workflow			`copilot workflow run`
Show the exact prompt the model sees		`codex debug prompt-input`
Server for other apps to drive the agent		`codex app-server`, `codex debug app-server send-message-v2`	`copilot --acp`
Company deployment (gateway, self-hosted runners)	`claude gateway`, `claude self-hosted-runner`

Inside a session

Sessions and conversations

What it does	Claude Code	Codex	Copilot CLI	Antigravity CLI
Start an empty conversation	`/clear` (`/reset`, `/new`)	`/clear`, `/new`	`/clear` (`/new`, `/reset`)	`/clear` (`/new`)
Resume an earlier session	`/resume` (`/continue`)	`/resume`	`/resume` (`/continue`)	`/resume` (`/switch`, `/conversation`)
Copy the conversation and switch to the copy	`/branch`	`/fork`	`/fork` (`/branch`)	`/fork` (`/branch`)
Copy the conversation into a background session and keep working here	`/fork`
Send the whole session to the background	`/background` (`/bg`)
Stop the background session you are attached to	`/stop`
Rename the session	`/rename`	`/rename`	`/rename`	`/rename`
Session details, checkpoints, and cleanup			`/session` (`/sessions`)
Archive the session		`/archive`
Delete the session		`/delete`	`/session delete`
One-line summary of the session	`/recap`
Export or share the conversation	`/export`		`/share` (`/export`)
Search the conversation			`/search` (`/find`)
Restart the tool, keeping open sessions			`/restart`
Change the working directory	`/cd`		`/cwd` (`/cd`)
Give access to another directory	`/add-dir`		`/add-dir`	`/add-dir`
List directories with access			`/list-dirs`
Exit	`/exit` (`/quit`)	`/exit`, `/quit`	`/exit` (`/quit`)	`/exit` (`/quit`)

Context and instructions

What it does	Claude Code	Codex	Copilot CLI	Antigravity CLI
See what fills the context window	`/context`	`/status`	`/context`	`/context`
Summarize the conversation to free space	`/compact`	`/compact`	`/compact`
Set when automatic compaction starts	`/autocompact`
Ask a side question that stays out of the conversation	`/btw`	`/side` (`/btw`)	`/ask` (`/btw`)	`/btw`
Attach a file to the chat		`/mention`
Connect the editor (VS Code and others)	`/ide`	`/ide`	`/ide`
Write a starter instruction file	`/init`	`/init`	`/init`
View or toggle instruction files	`/memory`		`/instructions`
Memory the agent writes itself	`/memory`	`/memories`

Model and reasoning

What it does	Claude Code	Codex	Copilot CLI	Antigravity CLI
Choose the model	`/model`	`/model`	`/model` (`/models`)	`/model`
Set reasoning effort	`/effort`	`/model`	`/model`
Fast mode	`/fast`	`/fast`		`/fast`
Consult a second model during a task	`/advisor`		`/rubber-duck`
Response style	`/output-style`	`/personality`
Multi-agent deep reasoning on one hard problem				`/boost`

Planning and running on its own

What it does	Claude Code	Codex	Copilot CLI	Antigravity CLI
Plan before editing	`/plan`	`/plan`	`/plan`	`/plan`
Keep working until a goal is met	`/goal`	`/goal`	`/autopilot` (`/goal`)
Rewrite a rough prompt into a clear one			`/refine`
Repeat a prompt on an interval	`/loop` (`/proactive`)		`/every` (experimental)
Run a prompt once, later			`/after` (experimental)
Scheduled tasks that run in the cloud	`/schedule` (`/routines`)

Permissions and safety

What it does	Claude Code	Codex	Copilot CLI	Antigravity CLI
Permission rules or mode	`/permissions` (`/allowed-tools`)	`/permissions`	`/permissions`	`/permissions`
Allow everything			`/allow-all` (`/yolo`)
Reset approvals given this session			`/reset-allowed-tools`, `/permissions reset`
Retry an action the automatic reviewer denied		`/approve`
Suggest allow rules from your past sessions	`/fewer-permission-prompts`
Set up auto mode for your environment	`/auto-mode-setup`
Sandbox	`/sandbox`		`/sandbox`
Windows sandbox setup		`/setup-default-sandbox`, `/sandbox-add-read-dir`
Hooks	`/hooks`	`/hooks`	`/env` (lists them)	`/hooks`
Privacy settings	`/privacy-settings`

Changes, undo, and review

What it does	Claude Code	Codex	Copilot CLI	Antigravity CLI
Undo	`/rewind` (`/checkpoint`, `/undo`)		`/undo` (`/rewind`)	`/rewind` (`/undo`)
See what changed	`/diff`	`/diff`	`/diff`	`/diff`
Code review	`/code-review` (`/review`)	`/review`	`/review`
Deep code review in the cloud	`/ultrareview`
Security review	`/security-review`		`/security-review`
Clean up the changed code	`/simplify`
Run the app to confirm a change works	`/run`, `/verify`
Teach `/run` how to start your app	`/run-skill-generator`
Review plans and other artifacts				`/artifact`
Search the codebase				`/codesearch` (`/cs`, `/search`)
Pull requests	`/autofix-pr`		`/pr`
Hand a task to a cloud agent that opens a PR			`/delegate`
Work in a git worktree			`/worktree`, `/move`, `/new worktree`
Split a large change across parallel agents	`/batch`		`/fleet`

Agents and parallel work

What it does	Claude Code	Codex	Copilot CLI	Antigravity CLI
Subagents	`/agents` (a reminder only)	`/agent` (`/subagents`)	`/agent`, `/subagents` (`/agents`)	`/agents`
Hand a side task to a subagent that reports back	`/subtask`
Background tasks and shells	`/tasks` (`/bashes`)	`/ps`	`/tasks`	`/tasks`
Stop background shells		`/stop` (`/clean`)
List agents and sessions to message	`/list-agents` (`/peers`)
Teams of agents for long projects				`/teamwork-preview` (`/teamwork`)
Multi-agent workflows	`/workflows`, `/workflow-authoring`		`/workflows`
Deep research with cited sources	`/deep-research`		`/research`

Skills, plugins, and outside tools

What it does	Claude Code	Codex	Copilot CLI	Antigravity CLI
Skills	`/skills`	`/skills`	`/skills`	`/skills`
Reload skills	`/reload-skills`		`/skills reload`
Context cost of each skill	`/skill-doctor`
Plugins	`/plugin`	`/plugins`	`/plugin`	`/plugin` (`/plugins`)
Reload plugins	`/reload-plugins`
Write a mod (plugin) with help	`/plugin-authoring`
Apps (connectors)		`/apps`
MCP servers	`/mcp`	`/mcp`	`/mcp`	`/mcp`
Language servers			`/lsp`
Extensions			`/extensions` (experimental)
Import another tool’s setup	`/import`	`/import`
Change settings by describing the change	`/update-config`

Apps, cloud, and other devices

What it does	Claude Code	Codex	Copilot CLI	Antigravity CLI
Move the session to the desktop app	`/desktop` (`/app`)	`/app`	`/app`
Pull a cloud session into the terminal	`/teleport` (`/tp`)
Default cloud environment	`/remote-env`
Connect GitHub for cloud sessions	`/web-setup`
Control this session from another device	`/remote-control` (`/rc`)		`/remote`	`/remote-control`
Get the mobile app	`/mobile` (`/ios`, `/android`)
Work in your Chrome browser	`/chrome`, `/claude-in-chrome`
Install the GitHub app	`/install-github-app`
Install the Slack app	`/install-slack-app`
Open a file in your editor				`/open`

Artifacts and design (Claude Code bundled skills)

What it does	Claude Code	Codex	Copilot CLI	Antigravity CLI
List and attach your artifacts	`/artifacts`
Artifact capabilities and diagram guidance	`/artifact-capabilities`, `/artifact-diagramming`
Make a slide deck	`/slides`
Draft UI designs	`/design`
Sync your design system	`/design-sync`, `/design-login`
Chart and dashboard guidance	`/dataviz`
Claude API reference for your project	`/claude-api`

Account and usage

What it does	Claude Code	Codex	Copilot CLI	Antigravity CLI
Usage and limits	`/usage` (`/cost`, `/stats`)	`/usage`	`/usage`	`/usage` (`/quota`)
Credits and spending limits	`/usage-credits`		`/limits`	`/credits`
Options when you hit a limit	`/rate-limit-options`
Upgrade your plan	`/upgrade`
Status: version, model, account	`/status`	`/status`
Sign in	`/login`		`/login`
Sign out	`/logout`	`/logout`	`/logout`	`/logout`
Switch accounts			`/user`
Share free trial passes	`/passes`

Settings and interface

What it does	Claude Code	Codex	Copilot CLI	Antigravity CLI
Settings	`/config` (`/settings`)		`/settings` (`/config`)	`/config` (`/settings`)
Show where each setting came from		`/debug-config`
Experimental features		`/experimental`	`/experimental`
Status line	`/statusline`	`/statusline`	`/statusline` (`/footer`)	`/statusline`
Terminal window title		`/title`		`/title`
Color theme	`/theme`	`/theme`	`/theme`
Prompt bar color	`/color`
Keyboard shortcuts	`/keybindings`	`/keymap`		`/keybindings`
Vim editing		`/vim`	`/vim`
Terminal renderer	`/tui`
Focus view	`/focus`
Raw scrollback for copying		`/raw`
Mouse scroll speed	`/scroll-speed`
Set up Shift+Enter for new lines	`/terminal-setup`		`/terminal-setup`
Voice dictation	`/voice`		`/voice`	`/voice` (`/record`)
Copy the last response	`/copy`	`/copy`	`/copy`	`/copy`
Terminal pet		`/pets` (`/pet`)
Keep the computer awake			`/keep-alive` (`/caffeinate`)
Preview interface components			`/clikit`, `/tuikit`

Help, updates, and diagnostics

What it does	Claude Code	Codex	Copilot CLI	Antigravity CLI
Help	`/help`		`/help`	`/help`
Interactive feature lessons	`/powerup`
Release notes	`/release-notes`		`/changelog` (`/release-notes`)
Version			`/version`
Update			`/update` (`/upgrade`)
Install an older version			`/downgrade`
Setup checkup	`/doctor` (`/checkup`)
Debug a problem in the session	`/debug`		`/diagnose`
Collect debug logs			`/collect-debug-logs`
Memory snapshot for a bug report	`/heapdump`
Send feedback or a bug report	`/feedback`, `/bug` (`/share`)	`/feedback`	`/feedback` (`/bug`)	`/feedback`
Report on how you have been using it	`/insights`		`/chronicle`
Onboarding guide for a teammate	`/team-onboarding`
Stickers and radio	`/stickers`, `/radio`

Tools the agent can use

The tools are what the model can ask the harness to do (Chapter 1). The names matter when you write permission rules and hooks, because rules and hooks match on them. Sources: Claude Code tools reference, Copilot CLI tool names, Antigravity supported tools. Codex has no tools reference; its column lists the tools its hooks page names, so a blank Codex cell is less certain than the others.

What it does	Claude Code	Codex	Copilot CLI	Antigravity CLI
Run a shell command	`Bash`, `PowerShell`	`exec_command` (matched as `Bash`)	`bash`, `powershell`	`run_command`
Send input to a running command		`write_stdin`	`write_bash`	`manage_task`
Read, list, or stop running commands	`TaskOutput` (deprecated), `TaskStop`		`read_bash`, `list_bash`, `stop_bash`	`manage_task`
React to a command’s output as it arrives	`Monitor`
Read a file	`Read`		`view`	`view_file`
List a directory			`view`	`list_dir`
Create a file	`Write`	`apply_patch`	`create`	`write_to_file`
Edit a file	`Edit`	`apply_patch`	`edit`, `apply_patch`	`replace_file_content`, `multi_replace_file_content`
Edit a Jupyter notebook	`NotebookEdit`
Find files by name pattern	`Glob`		`glob`	`find_by_name`
Search inside files	`Grep`		`grep` (`rg`)	`grep_search`, `code_search`
Code intelligence from a language server	`LSP`
Fetch a web page	`WebFetch`		`web_fetch`	`read_url_content`
Search the web	`WebSearch`	web search (hosted)	`web_search`	`search_web`
Drive a browser				`browser_` tools
Generate an image				`generate_image`
Ask you a question	`AskUserQuestion`		`ask_user`	`ask_question`
Keep a task list	`TaskCreate`, `TaskGet`, `TaskList`, `TaskUpdate`, `TodoWrite`	`update_plan`	`update_todo`
Enter or leave plan mode	`EnterPlanMode`, `ExitPlanMode`
Run a subagent	`Agent`	`spawn_agent`	`task`	`invoke_subagent`
Define a new subagent during the task				`define_subagent`
Message another agent	`SendMessage`, `ListAgents`		`write_agent`, `list_agents`	`send_message`
Check on or stop subagents	`TaskStop`		`read_agent`	`manage_subagents`
Hand a subagent’s report back	`SubagentHandback`
Run a skill	`Skill`		`skill`
Work in a git worktree	`EnterWorktree`, `ExitWorktree`
Schedule work for later	`CronCreate`, `CronList`, `CronDelete`, `ScheduleWakeup`, `RemoteTrigger`			`schedule`
Check or request permissions				`list_permissions`, `ask_permission`
Store a fact in memory			`memory` (permission kind)
Use MCP servers	MCP tools, `ListMcpResourcesTool`, `ReadMcpResourceTool`, `WaitForMcpServers`	MCP tools	MCP tools	MCP tools
Load tools only when needed	`ToolSearch`
Run a multi-agent workflow	`Workflow`
Publish a web page (artifact)	`Artifact`
Send you a notification or a file	`PushNotification`, `SendUserFile`
Report code-review findings	`ReportFindings`
Draft feedback about the tool	`SendFeedback`
Share an onboarding guide	`ShareOnboardingGuide`
End the conversation	`EndConversation`

Keys

What you want	Claude Code	Codex	Copilot CLI	Antigravity CLI
Cycle modes	`Shift+Tab`	Not listed; use `/permissions`	`Shift+Tab`	`Shift+Tab`
Stop the agent	`Esc`	Not listed; `Ctrl+C` closes the session	`Esc` twice	`Esc`
Point at a file	`@`	`@`	`@`	`@`
Run a shell command yourself	`!`	`!`	`!`	Not listed
New line	`Shift+Enter` or `Ctrl+J`	Not listed	`Shift+Enter`	`Shift+Enter` or `Ctrl+J`
Paste an image	`Ctrl+V`	Paste, or `codex -i`	`Alt+V`	`Ctrl+V`
Search past prompts	`Ctrl+R`	`Ctrl+R`	`Ctrl+R`	Not listed (`Ctrl+R` opens Artifact Review)
Queue a message while it works	Type and press Enter	`Tab`	`Ctrl+Q`	Not listed

Using one repo with all four

A builder template set up for Claude Code (a CLAUDE.md, skills in .claude/skills/, hooks in .claude/settings.json, MCP servers in .mcp.json) works in each tool to a different degree:

Your Claude Code file	Codex	Copilot CLI	Antigravity CLI
`CLAUDE.md`	Not read	Read	Not read
`.claude/skills/`	Not read	Read	Not read
Hooks in `.claude/settings.json`	Not read	Read, with Claude-style matchers	Not read
`.mcp.json`	Not read	Read	Not read

Copilot CLI reads Claude Code’s files on purpose (custom instructions, skills, hooks reference). For the other two, three steps cover most of it:

Put the shared rules in AGENTS.md, and make CLAUDE.md one line that imports it. Codex, Copilot, and Antigravity all read AGENTS.md; Claude Code reads the import.
```
@AGENTS.md
```
Link each skill into .agents/skills/, which Codex, Copilot, and Antigravity all read. Codex follows symlinked skill folders; for Antigravity, check that /skills lists them, and copy the folders if it does not.
```
mkdir -p .agents/skills
ln -s ../../.claude/skills/sprint-plan .agents/skills/sprint-plan
ln -s ../../.claude/skills/sprint-review .agents/skills/sprint-review
```
Rewrite hooks for each tool. Every tool sends the hook a description of the tool call as JSON, but the field names differ. The sections below show what changes.

Codex in detail

Sources: Codex CLI, CLI reference, AGENTS.md, approvals and security, rules, skills, hooks, memories. Codex documentation moved from developers.openai.com/codex to learn.chatgpt.com/docs; old links redirect.

Instructions

Codex reads one AGENTS.md per folder, from the repo root down to where you started; closer files come later and win. An AGENTS.override.md in the same folder is read instead of AGENTS.md. The combined limit is 32 KiB (project_doc_max_bytes). Codex does not read CLAUDE.md unless you add it to project_doc_fallback_filenames in config.toml.

Claude Code reads AGENTS.md itself (version 2.1.277 or later), but only when the project has no CLAUDE.md (memory). Each tool can copy the other’s setup: /import codex in Claude Code, /import in Codex.

Modes, rules, and sandbox

Claude Code asks permission for each action and offers an optional sandbox. Codex runs every command inside a sandbox by default, and permission decides when a command may leave it.

Claude Code permission mode	Closest Codex setting
Manual	Read Only: `--sandbox read-only --ask-for-approval on-request`
Plan	`/plan`
Accept edits	Auto, the default: `--sandbox workspace-write --ask-for-approval on-request`. Edits and commands inside the project run freely; leaving the project or using the network asks first
Auto	No direct equivalent. The Codex Auto preset is the sandbox above, not a background safety check
Bypass permissions	`--dangerously-bypass-approvals-and-sandbox` (alias `--yolo`). Only inside an isolated container or virtual machine

Chapter 2’s ask rules for commands that leave your laptop look like this in each tool:

Claude Code, .claude/settings.json

{
  "permissions": {
    "ask": ["Bash(git push *)",
            "Bash(vercel *)"]
  }
}

Codex, ~/.codex/rules/default.rules

prefix_rule(
    pattern = ["git", "push"],
    decision = "prompt",
)
prefix_rule(
    pattern = ["vercel"],
    decision = "prompt",
)

Codex’s decision values are "allow", "prompt" (Claude’s ask), and "forbidden" (Claude’s deny). A Codex rule governs commands that would run outside the sandbox. codex execpolicy check tests a rules file.

Hooks

Codex uses Claude Code’s event names (PreToolUse, PostToolUse, Stop, and others, 12 in all) and the same exit code 2 to block. Two things differ: a hook does not run until you trust it in /hooks, and a file-edit hook receives the whole patch as text in tool_input.command, not a file path.

Chapter 2’s git guard reads tool_input.command, which Codex also sends for shell commands, so it works unchanged. The .env guard reads tool_input.file_path, which Codex does not send. In Codex, check the patch text instead (match Edit|Write, which Codex maps to its apply_patch tool):

#!/bin/bash
# Block Codex from editing .env files
if jq -r '.tool_input.command' | grep -q '\.env'; then
  echo "Blocked: .env files hold secrets and must not be edited by the agent" >&2
  exit 2
fi
exit 0

This also blocks a patch that mentions .env anywhere in its text. Codex’s docs call tool hooks “a useful guardrail, not a complete enforcement boundary”; the same is true in every tool here.

Undo

Codex documents no file checkpoint. Esc twice lets you edit your previous message and fork the conversation, but it does not put your files back. Its own quickstart says: “Create Git checkpoints before and after a task so you can revert changes.” In the terms of Blast Radius, every Codex edit is group 2: commit before you start.

Copilot CLI in detail

Sources: Copilot CLI, install, command reference, hooks reference.

Getting it. Every Copilot plan includes Copilot CLI, including Copilot Free and Copilot Student, which is free for verified students through GitHub Education. Install it, run copilot, and type /login. A Microsoft 365 Copilot license, the assistant in Office and Teams, is a different product and does not sign you in.

Instructions and skills. Copilot combines every instruction file it finds (AGENTS.md, CLAUDE.md, GEMINI.md, .github/copilot-instructions.md) and has no precedence order between them, so keep them from contradicting each other. /instructions shows which files it loaded. Skills in .claude/skills/ work as they are.

Permission rules. Copilot has no committed file of allow, ask, and deny rules. You pass them at launch, and a deny always wins, even with --allow-all:

copilot --allow-tool='shell(git:*)' --deny-tool='shell(git push)'

The approval you give during a session (“Yes, and approve TOOL for the rest of the running session”) covers that tool for every later use in the session. Approving rm ./old-file.txt that way also approves rm -rf ./*. For a rule that applies in every session, use a preToolUse hook.

Hooks. Copilot reads hooks from .github/hooks/*.json and also from your .claude/settings.json. Hooks written with Claude’s event names (PreToolUse) get Claude-style matchers (Bash, Edit|Write) and a payload with tool_name and tool_input. Exit code 2 blocks. The arguments inside tool_input are Copilot’s own, so test each Chapter 2 script with a harmless call before you rely on it.

Undo. /undo offers “Conversation only” or “Conversation + files.” The second restores files Copilot changed through its edit tools, shell commands, and subagents, and skips any file you have edited since. That covers more than Claude Code’s /rewind, which does not track shell commands. Anything that left your laptop still cannot be undone.

Antigravity CLI in detail

Sources: getting started, CLI reference, execution modes, rules, skills, permissions, hooks, migrating from Gemini CLI.

Getting it. Install with the script in the Commands table, run agy in your project folder, and sign in with a Google account. Antigravity CLI shares settings and permissions with the Antigravity 2.0 desktop app. If you used Gemini CLI, agy offers to import its settings on first launch, and agy plugin import gemini converts its extensions.

Instructions. Antigravity reads AGENTS.md and GEMINI.md in every folder, plus .agents/rules/*.md. A file in .agents/rules/ needs frontmatter with a trigger (always_on, model_decision, glob, or manual); without it the rule is “silently discarded.” Rules have a 20,000-token budget, after which the largest files are shortened to a pointer.

Modes and permissions. Shift+Tab cycles default (shows each file edit as a diff for you to accept), accept-edits, and plan. Separately, allow, ask, and deny rules cover actions such as command(git push), write_file(path), and read_url(domain); deny beats ask, and ask beats allow. They live in your user settings file, not in the repo, so they do not travel with the project. Reading and writing files inside your workspace needs no rule; in default mode you still review each edit.

Hooks. Hooks go in .agents/hooks.json and use different names from the other three tools. The shell tool is run_command, and its command is in toolCall.args.CommandLine. File edits are write_to_file, replace_file_content, and multi_replace_file_content, with the path in toolCall.args.TargetFile. A PreToolUse hook answers with JSON such as {"decision": "deny", "reason": "..."} instead of an exit code. Chapter 2’s scripts need rewriting for these names. Note that "allow" approves the call without asking you, so a guard should not return it for commands it is not meant to check; check the hooks page for the current options.

Undo. /rewind rolls back the conversation. The reference does not say it restores files, and /fork copies the conversation, not your files. Use git.