Antigravity vs Codex CLI After Six Months in Production — Measured Comparison from Running Six Sites in Parallel

Concurrency shapes the project design

The single biggest lived difference was practical concurrency. Antigravity's manager view runs multiple agents, but past 4 in parallel, I started seeing "agents that cannot resolve their own merge conflicts" pile up. Codex CLI as a background batch held steady at 6.

That changes how I structure the pipeline, not just how many tasks I dispatch:

// pipeline-orchestrator.ts excerpt
// per-agent concurrency caps based on six months of observation
const AGENT_CONCURRENCY = {
  antigravity: {
    max: 4,
    suitableFor: ["frontend-refactor", "schema-migration", "long-running"],
  },
  codex_cli: {
    max: 6,
    suitableFor: ["batch-edit", "test-generation", "lint-fix"],
  },
} as const;
 
function assignAgent(task: PipelineTask): AgentType {
  if (task.estimatedDurationMin > 20) return "antigravity";
  if (task.parallelizable && task.batchSize > 4) return "codex_cli";
  if (task.requiresPlanning) return "antigravity";
  return "codex_cli";
}

In my live pipeline this maps cleanly: front-end refactors and schema migrations to Antigravity; mass dependency bumps, lint autofix, and test-scaffolding to Codex CLI.

Behavior on a deliberately broken repo

I broke four repositories on purpose and watched both agents try to recover:

• ① a critical file is 0 bytes (simulating a failed previous edit)
• ② package.json has contradictory dependency versions
• ③ 50+ TypeScript type errors
• ④ unresolved merge conflict markers in the tree

| Break               | Antigravity                                  | Codex CLI                              |
|---------------------|----------------------------------------------|----------------------------------------|
| ① empty file       | planning tries to restore from git history   | reconstructs from git log, often wrong |
| ② dep conflict     | proposes peer-dependency fix automatically   | stops, asks human to resolve           |
| ③ 50+ type errors  | works step by step, holds up over long tasks | parallelizes fixes, but regresses more |
| ④ merge conflict   | reads conflict markers, proposes resolution  | tends to skip conflicted regions       |

The takeaway I now apply: dependency-shaped breakage → Antigravity; mass lint/test mechanical work → Codex CLI.

Cost shape, not cost level

The two have very different cost shapes, which matters more than the absolute level:

Antigravity ($40 flat):
- 6 sites at 4-way parallelism, same monthly cost regardless of intensity
- Predictability is the win

Codex CLI ($50–$70 usage):
- Quiet month: $42
- Heavy month: $68 (when a big refactor lands)
- Bursts when you batch

I lean toward Antigravity for the steady-state site operations (the budget is the budget), and reach for Codex CLI when I have a once- or twice-yearly big push where usage-billing is fine because the burst is real.

Sharing a single MCP server across both

If you use both, a shared MCP server is what makes the comparison fair and the swap painless. In my pipeline:

// shared-mcp/server.ts
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 
const server = new Server(
  { name: "dolice-pipeline-tools", version: "1.0.0" },
  { capabilities: { tools: {} } }
);
 
server.setRequestHandler("tools/list", () => ({
  tools: [
    {
      name: "validate_mdx_frontmatter",
      description: "Check MDX frontmatter against the CLAUDE.md rules",
      inputSchema: { type: "object", properties: { mdxPath: { type: "string" } } },
    },
    {
      name: "run_article_quality_gate",
      description: "Run article_gate.py and return violations as JSON",
      inputSchema: { type: "object", properties: { jaPath: { type: "string" }, enPath: { type: "string" } } },
    },
    {
      name: "count_article_pairs",
      description: "Return JA/EN MDX file-count diff (for pre-push check)",
      inputSchema: { type: "object" },
    },
  ],
}));

I run this on one Cloudflare Worker for under $5/month. Both agents see the same tools, so the difference I measure between them is actually about the agents — not about tooling friction.

How to pick if you only get one

Three axes that have held up across these six months:

First: average task length on your codebase. If a typical task runs over 20 minutes — Antigravity. If most of your work is 5–15 minute slices — Codex CLI. My Site A (front-end refactors) is the first kind; Site D (small PHP edits) is the second.

Second: how you want the bill to look. Flat monthly budget you can defend without spreadsheets → Antigravity. Usage-based that scales with bursts → Codex CLI.

Third: team size. As a solo developer juggling many repositories, Antigravity's planning loop acts like a substitute human reviewer, which matters a lot when there is no actual second reviewer. With a real team, Codex CLI's higher parallelism starts paying off because there are humans to absorb its rougher edges.

After six months, I'm convinced the right framing is not "which one is better" but "which one fits the operating pattern you already have". I hope sharing the measured comparison helps anyone else trying to make this call.