Choosing Your Agent Platform: Claude Code, Codex CLI, OpenCode, and Antigravity CLI for Design Work

Which agent should I use? is the question designers ask first, and it is the question with the shortest shelf life. The June 2026 edition of this article still treated Gemini CLI as a current peer. On 18 June 2026 that CLI stopped serving individual, Google AI Pro, and Google AI Ultra requests. The individual terminal agent on that side is Antigravity CLI. Gemini Code Assist Standard and Enterprise licenses, and paid Gemini API keys, were left on Gemini CLI. This revision is dated 9 October 2026.

Teams still have to pick something. The honest version of this article does three things: it says what is different between Claude Code, Codex CLI, OpenCode, and Antigravity CLI as of that date; it separates those terminal agents from Cursor, Codex Cloud, and Copilot's cloud agent, which are different surfaces; and it keeps the decision smaller than the vendors want, because a portable harness moves in an afternoon.

Volatile facts — prices, config key names, and which product is current — are tied to a source. Stable facts — AGENTS.md loaded on every turn, SKILL.md loaded when a task needs it, MCP as the connector — are stated plainly. Release version numbers from the June draft are gone. They were already the wrong thing to memorize.

The durable shift is still the open layer. Codex CLI and OpenCode read AGENTS.md natively. Claude Code reads it through an import in CLAUDE.md. Antigravity CLI treats both AGENTS.md and GEMINI.md as always-on rules for their directory, with no frontmatter. Skills are the on-demand layer: a name and description can be visible, and the SKILL.md body loads when the task calls it. Codex, OpenCode, and Antigravity CLI discover workspace skills from .agents/skills/. Claude Code discovers .claude/skills/. All four speak MCP, so the same Playwright, Figma, or canvas server works once you translate the config syntax. The instruction-hierarchy article and the harness article cover the file mechanics; this one assumes them.

That convergence has a practical consequence that vendors do not advertise: the durable asset is not the platform, it is the harness. Your DESIGN.md, your tokens, your AGENTS.md, your skills, your example screenshots, and your review gates are plain files in your repository. They are the part that took weeks to get right, and they are the part that moves. What does not move is operational: permission and approval settings, sandbox flags, plans and usage windows, model selection, and platform-only conveniences like Claude Code's path-scoped rules or agent teams. Rebuilding that layer when you switch platforms is roughly an hour of work, not a migration project.

Hold on to that asymmetry, because it reframes the whole decision. If switching costs an hour and the harness carries the design knowledge, then choosing a platform is closer to choosing a text editor than choosing a design tool. You can be wrong, notice, and move — provided you did not let platform-specific config become the only place your design knowledge lives.

Feature checklists stopped being useful in 2026 because everyone checks every box. Instruction file: yes, four times. Skills: yes. MCP: yes. Subagents: yes. Image input: yes, with caveats. If you compare platforms by counting checkmarks you will conclude they are interchangeable, which is half true and entirely unhelpful. The differences that change a designer's week live one level down, in how each capability is operated and governed.

Five criteria carry most of the weight for design-to-code work. First, sandboxing and permission ergonomics: how the platform contains a mistake, and how often it interrupts you to ask. A screenshot-verify loop that needs approval for every browser action is unusable; an agent with unrestricted shell access on a client project is a different kind of unusable. Second, model access and context: which models you can use, whether you can swap them, and how much of a design system fits in one conversation — read the current model card, not a remembered ranking. Third, the pricing model — not the headline number, but the shape: subscription usage windows, included usage plus credits, or bring-your-own-key. Fourth, design-specific surfaces: image input, a browser, MCP, and whether you can point at the running UI. Fifth, governance and churn: who controls the platform, what is open source, and how exposed you are if the vendor renames the product.

Three surfaces sit beside this CLI comparison and are easy to flatten. Cursor's Agents Window is the agent-first workspace, generally available with Cursor 3 since 2 April 2026. Design Mode lives in the browser inside that window: Cmd+Shift+D, then click an element, draw a region, or dictate, and the agent edits the underlying code. Cursor skills and subagents are documented separately from that pointing gesture. Codex in the IDE extension is the interactive local agent; Codex Cloud runs tasks on OpenAI-managed computers and can keep going while your machine is off. GitHub Copilot's IDE agent mode edits the local workspace while you supervise. Copilot cloud agent works in a GitHub Actions environment and can open a pull request. Copilot is not an autocomplete product in either of those modes.

Notice what is not on the list: model quality benchmarks. Not because quality does not matter, but because frontier models leapfrog each other every few months, every platform can run a current frontier model, and the published coding benchmarks measure tasks that look nothing like translating a design system into components. Your own harness run through a real brief is a better benchmark than any leaderboard, and it costs an afternoon.

• Sandboxing and permission ergonomics: containment when things go wrong, and how often the tool interrupts you when they do not.
• Model access and context: which models, whether you can swap them, and how much design context fits in one session.
• Pricing shape: subscription usage windows, metered token credits, or bring-your-own-key — each fails differently under heavy design iteration.
• Design surfaces: image input, browser and screenshot loops, and the skill, plugin, and MCP ecosystem you can adopt instead of building.
• Governance and churn: open source versus proprietary, and the realistic cost to you if the platform pivots or retires.

Cursor Design Mode points at the running UI. Codex splits an IDE agent from Codex Cloud. Copilot splits IDE agent mode from a cloud agent. Antigravity CLI is the individual successor. Gemini CLI is not drawn as that peer.

Claude Code is Anthropic's agent: a proprietary client in front of proprietary models. It reads a CLAUDE.md hierarchy, supports path-scoped rules, and imports AGENTS.md when you point CLAUDE.md at it. Skills live in .claude/skills/ and follow the Agent Skills format, with Claude-specific extras such as forked execution. Hooks run your own check at lifecycle events, outside the prompt. Subagents run in their own context. The browser path documented for designers is Claude in Chrome, toggled with /chrome, plus ordinary MCP servers such as Playwright.

The trade-off is plan economics. On 9 October 2026, claude.com/pricing listed Pro at $20 per month or $17 per month billed annually, and the Max help article listed $100 per month for 5x Pro usage and $200 per month for 20x. The pricing FAQ still describes rolling five-hour windows shared with the Claude apps, plus weekly limits, and usage credits at API rates when a paid plan hits the window. This review did not re-check a release version number.

Codex CLI is OpenAI's terminal agent. The client is open source; the models and the service are not. It reads AGENTS.md, discovers skills from .agents/skills/, and stores MCP servers in config.toml under mcp_servers, either in ~/.codex/config.toml or in a trusted project's .codex/config.toml. A remote HTTP server uses a url field. The IDE extension is the interactive local agent and can see open files. Codex Cloud is the other product: tasks run on OpenAI-managed computers, can continue while your machine is asleep, and can be handed a local thread.

Local Codex uses an OS-level sandbox separate from the approval policy. Cloud tasks use an isolated environment whose setup phase can use the network and whose agent phase is offline unless you enable network for that environment. Do not describe those as the same computer.

Codex is included with ChatGPT plans. Plus is $20 per month. Pro tiers on the help article are $100, $200, and $500 per month, with a sign-up pause note still sitting on the Plus article for new $200 subscriptions. Business standard seats are $25 per user per month or $20 billed annually, and premium seats are $125 or $100 annually. Included usage is used before credits. Visual iteration is what moves that meter.

OpenCode is the open-source option, MIT-licensed, maintained by Anomaly, repository anomalyco/opencode. The agent is free. You bring models: your own API keys, Zen pay-as-you-go credits, or Go. On 9 October 2026 the Go docs listed Go at $10 per month and Go Plus at $40 per month. The Zen page asks for a $20 balance and reloads $20 when the balance falls under $5. Several Zen models are marked free, and that roster is not a budget.

OpenCode reads AGENTS.md and discovers skills from .opencode/skills/, .claude/skills/, and .agents/skills/. MCP servers live in the mcp block of opencode.json, with type local or type remote. This review did not re-test whether OpenCode has an operating-system sandbox. If that distinction matters for a client repository, read the current permission docs before you treat policy rules as containment.

There is no first-party design surface. Vision depends on the model you attach. The reason to pick OpenCode is that the harness ports and the model is yours to swap.

Gemini CLI is not the individual peer anymore. Google's 19 May 2026 announcement said Gemini CLI and the Gemini Code Assist IDE extensions would stop serving Google AI Pro, Ultra, and free individual requests on 18 June 2026. That date has passed. Gemini Code Assist Standard and Enterprise, and paid API-key access, stayed on Gemini CLI. The individual terminal successor is Antigravity CLI. This review did not find a primary source that says Stitch replaced Gemini CLI, so this article does not say that.

Antigravity's own docs, read on 9 October 2026, are specific enough to configure from. AGENTS.md and GEMINI.md are always-on rules. Skills in .agents/skills/ become slash commands and load when used. MCP servers go in ~/.gemini/config/mcp_config.json or .agents/mcp_config.json. Remote servers use serverUrl. The legacy keys url and httpUrl are not accepted. /plan, and agy --mode=plan, research with read-only tools and present a plan before writing. The default toolPermission is request-review. There is no separate Antigravity subscription: the US Google AI plans page lists Plus at $4.99 with limited agent requests, Pro at $19.99 with expanded requests, and Ultra at $99.99 and $199.99.

The transition is the evidence for this article's thesis. A maintained, widely installed CLI became migration homework. If the harness lived in AGENTS.md, .agents/skills/, and a written MCP server list, the move is an adapter. If it lived only in Gemini-specific settings, it is a rebuild.

The matrix condenses the four terminal agents. Rows about file names change slowly. Rows about price and product names were re-read on 9 October 2026 and will move again. The June matrix image, which still showed Gemini CLI as the fourth column and a ~$8 Google floor, is not shown.

Read horizontally, instructions, skills, and MCP are the same idea with different filenames. Read vertically, Claude Code pairs skills, hooks, subagents, and a browser with subscription windows. Codex pairs a local IDE agent with a separate cloud agent and credit metering. OpenCode trades a first-party model for keys you manage. Antigravity is the current Google terminal agent for individual plans.

Turning the criteria into a sequence keeps the decision honest, because it forces the boring questions to come before the interesting ones. The flow below is ordered by how much each question constrains the answer, not by how much fun it is to debate.

Start with money you already spend: most design teams sit inside organizations that already pay for Claude or ChatGPT, and the agent included in that plan is the cheapest one to evaluate seriously. Then ask about safety rails, because they are non-negotiable when they apply at all — client repositories, regulated environments, shared machines. Then model flexibility: if you need to swap providers, run open-weight models, or control exactly which model sees client work, OpenCode is the platform built around that need. Then context size, for the minority of teams whose design system genuinely cannot be chunked — and check the current numbers on official model pages rather than trusting any article, this one included. Last, churn tolerance: how much would it cost you, in real hours, if your platform stopped serving your plan? Gemini CLI already did that for individual accounts.

The flow ends where the article began: whatever the answers point to, keep the harness in the open formats so the decision stays reversible. A platform choice you can revisit in an afternoon is a low-stakes choice, and low-stakes choices do not deserve months of deliberation.

To test how much the platform actually changes the output, we ran one design brief through two platforms with an identical harness. The brief: a marketing hero plus a three-item feature grid for a school landing section, built against this site's DESIGN.md tokens, responsive at 360, 768, and 1280 pixels, semantic tokens only, and consistent with the written direction — editorial, bookish, no gradient decoration. The harness: the same AGENTS.md project rules, the same DESIGN.md, and the same prototype skill, with Claude Code reading the shared rules through its CLAUDE.md import and OpenCode reading the same files directly. Honesty notes first: the Claude Code leg is traced from a real session in this repository's harness. The OpenCode leg is an honestly reproduced trace — the harness portability was verified by inspection (OpenCode's documented discovery order picks up this repository's AGENTS.md, CLAUDE.md fallback, and existing skill folders without any edits), but the generation run itself was reconstructed from documentation and from equivalent runs rather than executed in this environment, so it gets no quality score. Codex CLI and Antigravity CLI were not run at all and are described from documentation. This October review did not re-meter the session, so it no longer quotes a dollar cost for it.

The Claude Code run took three iterations over roughly forty minutes. The first pass produced a structurally correct section that reused the site's heading and badge components and stayed inside the token system — the harness doing its job — but invented a two-tone split background that the design system does not use, and set the feature grid at an even three columns on tablet where the content wanted two. The second pass fixed both against the written direction. The third pass was triggered by the review gates, not by taste: the design audit passed, but the accessibility check flagged a heading-level skip introduced when the hero title was demoted to make room for an eyebrow label. The session stayed inside a Pro plan's shared usage window. A previous draft attached a June API dollar estimate. That estimate was not re-measured, so it is not repeated.

The reproduced OpenCode leg is most useful for what it confirms and what it changes. Confirmed: the harness loads without modification — same instruction file, same skill, same MCP-driven screenshot loop — which is the portability claim this article needed to prove, and the part that was genuinely verified. Changed: the operational texture. Model choice becomes your decision, and with it the cost profile. Permissions had to be re-declared in opencode.json because nothing carries over from Claude Code's settings. The honest conclusion from the pair: the harness determined what good looked like and most of how fast both runs got there; the platform determined how the work was contained, metered, and paid for. That is the right division of labor, and it is the reason the harness deserves more of your investment than the platform decision does.

Here is what the portability looks like as files. The block below shows one repository carrying a single source of design truth and the thin per-platform adapters around it. The shared layer is three things: AGENTS.md for project rules, a skills folder in the open location, and DESIGN.md plus tokens for the design system. Everything else is an adapter measured in lines, not days.

Two practical notes. First, keep one instruction file as the source and make every other file a pointer or import — duplicated instructions drift apart within weeks, and an agent reading the stale copy will follow it confidently. Second, check discovery rather than assuming. As of the docs read on 9 October 2026, Codex CLI and OpenCode read .agents/skills/ directly, OpenCode also reads .claude/skills/, Claude Code wants .claude/skills/, and Antigravity CLI reads AGENTS.md itself as an always-on rule plus skills from .agents/skills/.

my-product/
├── AGENTS.md                    # always loaded: Codex, OpenCode, and Antigravity
├── DESIGN.md                    # design system: tokens, components, anti-patterns
├── tokens/                      # DTCG 2025.10 token JSON
├── .agents/
│   ├── skills/
│   │   └── design-prototype/
│   │       └── SKILL.md         # on demand: Codex, OpenCode, Antigravity
│   └── mcp_config.json          # Antigravity MCP; remote servers use serverUrl
│
│  # --- per-platform adapters ---
├── CLAUDE.md                    # Claude Code: one line — "@AGENTS.md"
├── .claude/
│   ├── skills/                  # symlink or copy of .agents/skills/
│   └── settings.json            # permissions: NOT portable, rebuild here
├── .mcp.json                    # Claude Code project MCP servers
├── .codex/config.toml           # Codex MCP servers; or ~/.codex/config.toml
└── opencode.json                # OpenCode: MCP servers, permissions, model choice

MCP is the layer that makes design tooling portable: the same Playwright server that drives a screenshot-verify loop, or the same Figma server that reads design context, works on every platform. What differs is where you declare it, and the key name for a remote URL. The snippet below was checked against Claude Code, Codex, OpenCode, and Antigravity docs on 9 October 2026. Antigravity rejects the old Gemini keys url and httpUrl.

The server is identical in all four; only the syntax changes. This is worth showing precisely because it is boring — translating these declarations is the entire MCP migration cost when you switch platforms. Keep a plain-text list of the servers your design workflow depends on, with the command and any environment variables, and you can regenerate any of these blocks in minutes.

// Claude Code — .mcp.json (project scope)
{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@playwright/mcp@latest"]
    }
  }
}

# Codex CLI — ~/.codex/config.toml or .codex/config.toml
[mcp_servers.playwright]
command = "npx"
args = ["@playwright/mcp@latest"]

// OpenCode — opencode.json
{
  "mcp": {
    "playwright": {
      "type": "local",
      "command": ["npx", "@playwright/mcp@latest"],
      "enabled": true
    }
  }
}

// Antigravity CLI — .agents/mcp_config.json
{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@playwright/mcp@latest"]
    }
  }
}

Prices in this article were re-read on 9 October 2026. The longer table, including the figures this site refuses to print, is in the pricing article. The short version: Claude Pro is $20 monthly or $17 annual, Max is $100 and $200, ChatGPT Plus is $20, ChatGPT Pro lists $100, $200, and $500, Business seats start at $20 per user on annual billing rather than the old $30 figure, OpenCode Go is $10 and Go Plus is $40, and the US Google AI plans are Plus $4.99, Pro $19.99, and Ultra $99.99 and $199.99. ChatGPT Go's amount is not quoted.

More useful than the numbers is the shape of each model under design workloads. Visual iteration is token-heavy: screenshots in, screenshots out, long design-system context, repeated regeneration. Subscription windows fail by making you wait — you hit the window mid-iteration and the loop stalls. Token credits and API metering fail by surprising you — the loop never stalls but the meter runs, and a heavy review day costs multiples of a normal one. Bring-your-own-key fails by becoming nobody's job — costs spread across personal keys until finance asks a question no one can answer. None of these is wrong; pick the failure mode your team can manage, and measure your own usage during the evaluation week rather than extrapolating from anyone else's.

The first anti-pattern is choosing on benchmarks. Published coding leaderboards measure algorithmic problem-solving, not whether an agent respects a spacing scale or notices that a card pattern already exists. The second is trusting feature checklists, including the matrix in this article: a checkmark says a capability exists, not that it is pleasant to operate, and the differences that cost you an afternoon live in the operating, not the existing. The third is hard-coding your design knowledge into settings only one vendor loads — permission rules treated as documentation, skills in a proprietary location — which converts a reversible choice into a hostage situation. AGENTS.md is safe to keep even when a tool also reads GEMINI.md. The fourth is quoting prices, versions, or context windows without dates.

There are also limits to what this article can claim. Only Claude Code was executed against the case-study brief in this repository. The OpenCode leg was reproduced and labeled. Codex CLI and Antigravity CLI are described from their documentation, which was re-read on 9 October 2026, not from a design run. This article can compare file formats, config keys, and pricing shapes. It cannot tell you which platform produces the best design output for your stack. Naming Gemini CLI's retirement is a fact about churn, not a verdict on Google's models.

Finally, the portability argument has its own limit. A harness ports; a team's muscle memory does not. Keyboard habits, permission reflexes, the shape of a good prompt for a particular model — those take a week or two to rebuild after a switch, and during that week output quality dips. Portability makes switching cheap, not free. The point is to keep the cost low enough that you can act on new information, not to pretend the cost is zero.

• Do not choose on coding benchmarks; run your own harness through a real brief instead.
• Do not treat feature checklists as comparisons; the differences live in ergonomics, pricing shape, and governance.
• Do not let design knowledge live only in platform-specific files; keep the source of truth in the open formats.
• Do not quote prices, versions, or context windows without a verification date — and do not trust anyone else's that lack one.
• Do not read platform descriptions written from documentation as if they were tested results; this article labels which is which.

The practical close is not a recommendation — it is a procedure, because the honest answer to which platform changes with your constraints and with the calendar. If you have a harness, you can evaluate any platform against your own work in about thirty minutes, and the same checklist doubles as a migration checklist when a platform forces your hand the way Gemini CLI did for individual plans.

Run it on the platform your existing subscription already includes, then on one alternative — the comparison teaches you more than either run alone. Keep the notes. The next time pricing changes, a feature you rely on moves, or a deprecation notice lands, you re-run the same thirty minutes instead of re-litigating the whole decision.

The last item on the checklist is the one that keeps this article useful after its facts age: put the platforms you depend on into a re-verification loop. This site does that through its tool-watch process — a recurring research pass over each platform's changelog, pricing page, and announcement feed that flags changes for review rather than letting articles silently rot. You do not need anything that formal: a calendar reminder to re-read four pricing pages and four changelogs once a quarter, and a habit of writing last verified next to every volatile fact in your own internal docs, captures most of the value.

# Platform evaluation — ~30 minutes with an existing harness

## Setup (10 min)
- [ ] Install the CLI; authenticate with the plan or API key you would actually use
- [ ] Confirm it reads your AGENTS.md (Claude Code: one-line import in CLAUDE.md;
      Antigravity reads AGENTS.md directly)
- [ ] Confirm it discovers your skills folder; map or symlink if needed
- [ ] Declare your MCP servers in the platform's config format
- [ ] Set permissions/sandbox to the strictest mode you can work in

## Run (15 min)
- [ ] Run your standard evaluation brief (the same one every time)
- [ ] Note: iterations to acceptance, wall-clock time, interruptions for approvals
- [ ] Run your review gates (build, design audit, accessibility check)
- [ ] Check usage/cost: window consumed, credits burned, or tokens billed

## Decide (5 min)
- [ ] Record results next to previous platforms' results, with today's date
- [ ] Note anything that required editing the harness itself (it should be nothing)
- [ ] List what would NOT port if you adopted this platform and later left it
- [ ] Add the platform's changelog + pricing page to your re-verification loop
- [ ] Date-stamp every volatile fact you wrote down: "last verified <date>"