May 2026 agent stack update: Antigravity 2.0, GPT‑5.5 Codex, Copilot billing — and the configs you should actually check in

The last 60 days reshuffled the AI coding desk. Google turned Antigravity into a full agent suite, OpenAI shipped GPT‑5.5 and made Codex truly cross‑platform, Copilot is pivoting its billing, Cursor iterated again on Composer, Windsurf bundled Devin, and Kiro simplified pricing — all while Claude Code kept leaning into terminal‑first autonomy [1]. If you’ve been waiting for the market to “settle,” it sort of has — not around a winner, but around a layered workflow most teams can live with.

What actually changed (and why it matters)

• OpenAI Codex leveled up as a cloud agent: GPT‑5.5 under the hood, Windows desktop app, PAYG seats — good for long‑running jobs in a managed sandbox [1], [5].
• Google Antigravity 2.0 is now a family: a redesigned desktop app for orchestrating parallel sub‑agents, a new Go CLI, and a Managed Agents service for scheduled/background runs [5].
• GitHub Copilot is moving to flex billing June 1 with a new Max plan — expect orgs to rethink how they allocate seats vs. heavier agent tools [1].
• Cursor, Windsurf, and Kiro shipped meaningful updates: Cursor Composer 2.5, Windsurf 2.0 bundling a Devin Cloud agent + Devin Terminal CLI, and Kiro’s simpler credit model with parallel Spec tasks [1].

The upshot: teams aren’t replacing tools — they’re composing them. Cursor still rules inside the editor, Claude Code owns the terminal/agent surface, and Codex is gaining for asynchronous cloud runs. Adoption mirrors that split: Copilot remains the most broadly deployed at work, with Cursor and Claude Code closing the gap; Codex has real usage momentum and seven‑figure weekly actives [5].

Where each tool fits in a 2026 workflow

The best way to choose is by “job to be done,” not by brand loyalty.

• Claude Code: strongest autonomy and multi‑file refactors; excels in terminal/CLI‑driven work and larger, production‑grade changes [4], [5].
• Cursor: best IDE‑native editing and inline experience; many engineers pair it with a terminal agent for big operations [4], [5].
• OpenAI Codex: runs tasks in a secure cloud sandbox, now desktop + CLI friendly; great for long‑running or scheduled background jobs and integrations in the OpenAI ecosystem [1], [5].
• GitHub Copilot: autocomplete‑first, enterprise‑familiar, cost‑efficient at scale — complements an agent, doesn’t replace it [4].
• Gemini/Antigravity CLI + Desktop: emerging as a parallel‑agents orchestrator and managed runtime; compelling if you’re deep in Google Cloud [5].

Clarista’s 2026 comparison lines up with what I see in the field: Claude Code wins raw code quality/autonomy, Cursor wins dev‑experience, Copilot wins cost/familiarity, and Codex/Gemini shine in narrower but important niches [4].

Ship your project’s agent “contract” (CLAUDE.md, AGENTS.md, Copilot instructions)

If you only do one thing this week, add first‑party config files to your repo. Every major assistant now reads project‑level instructions, and the file conventions are converging [2]:

• Claude Code: CLAUDE.md at project root (plus optional ~/.claude/)
• Codex CLI: AGENTS.md (with AGENTS.override.md for local tweaks)
• Gemini CLI: GEMINI.md (plus ~/.gemini/)
• Cursor: .cursor/rules/*.mdc (replacing legacy .cursorrules)
• Copilot: .github/copilot-instructions.md (with optional scoped files)

Here’s a minimal, production‑ready trio:

CLAUDE.md

# Project guardrails
- Language: TypeScript, Node 20, pnpm
- Code style: ESLint + Prettier (airbnb-base), strictNullChecks
- Security: never write plaintext secrets; prefer AWS Secrets Manager
- Tests: vitest + react-testing-library; aim for 80% coverage on new code
- PR policy: small, reviewed, green CI before merge

# Context
- Monorepo: apps/web, packages/api, packages/ui
- Services: Postgres, Redis; infra via Terraform in infra/terraform

AGENTS.md

# Tasks
- "refactor:web:routes": refactor Next.js app routes with app router; update tests
- "migrate:db:users": add last_login_at; backfill from audit logs via job

# Constraints
- Do not change infra/terraform without explicit approval
- Never expose secrets; use env vars and parameter store helpers

.github/copilot-instructions.md

# Editing style
Prefer small, composable functions. Keep JSX components under 200 lines. Inline types over interfaces unless reused 3+ times.

# Project norms
- pnpm only; lockfile must update on dep changes
- Use zod for runtime validation; never roll custom validators

These files eliminate guesswork and make multi‑agent setups consistent across machines and CI. The exact locations and formats above match what the tools expect today [2].

Standardize “skills,” not just prompts

Prompts drift. Skills persist. The SKILL.md format became an open standard in late 2025 and now works across Claude Code, Copilot, Codex CLI, Gemini CLI, Cursor, and more — which means one well‑built skill can travel with your repo and your team’s tool choices [3].

Example: a portable code‑review skill.

skills/code-review/SKILL.md

---
name: code-review
version: 1.1.0
triggers:
  - pr_opened
  - pr_updated
inputs:
  repo_path: ./
  severity_threshold: medium
outputs:
  report_path: ./reports/code-review.md
policies:
  - forbid-secrets
  - require-tests-changed
---

# Goal
Perform a security‑focused review of the diff with special attention to:
- SQL injection and unsafe string interpolation
- AuthZ checks on any new routes
- Insecure deserialization or eval‑like patterns

# Steps
1. Load the PR diff and map modified files to owning packages.
2. Run static checks (eslint --max-warnings=0) and capture errors.
3. Annotate risky patterns with concrete code suggestions and links to docs.
4. Fail if severity >= input.severity_threshold.

Because SKILL.md is portable, you can install and run it across tools (and even discover off‑the‑shelf skills via community marketplaces) without rewriting for each vendor [3].

When to run “in the cloud” vs. “at your desk”

• Choose Codex or Antigravity’s managed agents for long‑running tasks, integration tests that need real services, or scheduled chores. The cloud sandbox + desktop/CLI combo makes this ergonomic now [1], [5].
• Choose Claude Code or Cursor locally for exploratory refactors, fast feedback, and tight inner‑loop edits [4], [5].

A pragmatic pattern I like: kick off Codex background jobs from CI for “heavy” migrations while developers iterate locally with Claude/Cursor on the PR’s surface area. It keeps latency low for humans without starving the background work.

Cost control without neutering your agents

• Move routine inline help to Copilot; it’s cheap at scale and keeps agents free for higher‑leverage work [4].
• Use project configs (above) to limit scope — agents spend fewer tokens wandering.
• Exploit new billing levers: Copilot’s flex transition gives finance knobs without removing access [1].
• Prefer cloud runs (Codex/Antigravity) for long jobs where pause/resume and auditability matter [1], [5].

A sample “multi‑agent” dev loop

• In the IDE: Cursor for inline edits and quick tests.
• In the terminal: Claude Code for multi‑file refactors and repo‑wide operations.
• In CI: Codex job for background migrations on a branch; optional Antigravity Managed Agent for scheduled checks.
• Everywhere: shared CLAUDE.md/AGENTS.md/Copilot instructions, plus a portable SKILL.md library.

This isn’t theoretical — it reflects how usage is converging in the data: layered stacks over single winners [5] and side‑by‑side strengths across tools [4].

Key takeaways

• The market stabilized into a layered stack: Cursor in‑IDE, Claude Code terminal/agent, Codex for cloud jobs, Copilot for cost‑efficient inline help [4], [5].
• Antigravity 2.0 and GPT‑5.5 Codex changed the calculus for parallel and background runs [1], [5].
• Commit repo‑level configs (CLAUDE.md, AGENTS.md, Copilot instructions) to make agents predictable [2].
• Standardize on SKILL.md so your hard‑won workflows travel across tools [3].

References

1. AI Coding Agents & IDEs: The Complete 2026 Comparison – Claude Code vs Antigravity 2.0 vs Codex vs Cursor vs Kiro vs Copilot vs Windsurf — Lushbinary Team: https://lushbinary.com/blog/ai-coding-agents-comparison-cursor-windsurf-claude-copilot-kiro-2026
2. CLAUDE.md, AGENTS.md & Copilot Instructions: Configure Every AI Coding Assistant — DeployHQ: https://www.deployhq.com/blog/ai-coding-config-files-guide
3. Agents vs. Skills: Teaching Your AI Coding Assistant to Be Consistently Great — Spyglass: https://www.spyglassmtg.com/blog/agents-vs.-skills-teaching-your-ai-coding-assistant-to-be-consistently-great
4. Claude Code vs Cursor vs Codex vs Copilot vs Gemini CLI — the 2026 comparison — Clarista: https://www.clarista.io/blog/claude-code-vs-cursor-vs-codex
5. AI Weekly: Google Reshapes the Coding Stack, Claude Pulls Ahead — AM Data Lakehouse: https://amdatalakehouse.substack.com/p/ai-weekly-google-reshapes-the-coding