In April I reviewed three AI coding tools — Cursor, GitHub Copilot, and Claude Code — and called it a race. Re-reading that piece now, it feels like a postcard from a different era. The category has split in two: the autocomplete assistants that suggest the next line, and the agents that take a task, plan it, edit ten files, run the tests, and hand you a pull request. This piece is about the second group, because that's where the leverage is.
I'm still not a software engineer. I'm an operator who codes to ship — affiliate sites, automation scripts, data pipelines, the occasional bit of glue that holds a business together. That's the lens here. I don't care which agent tops a research leaderboard by half a point. I care which one gets a real task across the finish line without me babysitting it or blowing the monthly budget.
Here's the thing almost every roundup buries: the frontier models have basically converged. Opus, GPT-5.5, Gemini 3 — on everyday work you'd struggle to tell them apart. What actually separates these tools now is the harness around the model: how it plans, how it uses your terminal, how it handles context, and how badly it drains your wallet doing it. Pick the harness, not the logo.
The 2026 Landscape at a Glance
| Agent | Entry Price | Runs On | Best For |
|---|---|---|---|
| Claude Code | $20/mo | Claude Opus 4.8 | Deep, multi-file work in the terminal |
| OpenAI Codex | $8/mo | GPT-5.5 | Async cloud tasks across surfaces |
| Cursor | $20/mo | Composer 2.5 (+ any model) | Visual, in-editor daily driving |
| GitHub Copilot | Free / $10/mo | Multi-model | Teams living inside GitHub |
| Google Antigravity | Free | Gemini 3.5 Flash (+ others) | Parallel agents on a budget |
| OpenCode | Free (BYO key) | Any of 75+ providers | Tinkerers who want no lock-in |
| Devin | $20/mo | SWE-1.x | Fire-and-forget autonomous PRs |
Now the part that matters — who each one is actually for.
Claude Code — The Power User's Pick
Claude Code is still the one I reach for when the task is real. It's CLI-first (with VS Code, JetBrains, web, and mobile now hanging off the same engine), and it runs on Claude Opus 4.8. On SWE-bench Verified — the benchmark that most resembles fixing actual repo issues — it posts around 88.6%, the highest of the group. But the number isn't why I use it.
I use it because the harness is the deepest on the market: hooks that fire on events, reusable Skills, dynamic multi-step workflows, and full MCP support so it can reach your other tools. When I point it at a messy codebase and say "figure out why the build breaks and fix it," it actually does the loop — read, plan, edit, run, verify — instead of confidently handing me a broken guess.
The catch
Claude Code is the heaviest token spender in the field — roughly 3–4x what Codex burns on the same task. On the $20 Pro tier you'll hit limits fast on big jobs; the $100 Max plan is the realistic home for anyone using it daily. It's the most capable agent here, and also the one most likely to surprise you on a usage screen.
OpenAI Codex — The Efficiency Play
Codex is the value pick, and it's closed a lot of ground. It runs on GPT-5.5, starts at just $8/mo on the Go tier ($20 Plus, $100 Pro above that), and it's genuinely everywhere — CLI, cloud, IDE, desktop app, mobile — with your session following you across all of them. On Terminal-Bench, the test for how well an agent drives a real shell, GPT-5.5 sits at the top of the pack (~83%).
The headline feature is Codex Cloud: hand off a task and it runs asynchronously in the background while you do something else, then reports back. For an operator juggling five projects, that's a real workflow, not a demo. The recurring complaint is usage limits that cut in mid-task on lower tiers — annoying when you're in flow. But dollar for dollar, Codex is the most efficient serious agent right now.
Cursor — Still the Best Seat
If you want an agent that lives inside a real editor with a visual safety net, Cursor is still the most pleasant place to work. It's a VS Code fork built around its own Composer 2.5 model (or bring your own), and the in-editor agentic editing — visual diffs, multi-file changes you can eyeball before accepting, project Rules, subagents — remains best-in-class for day-to-day coding.
Pricing runs $20 Pro, $60 Pro+, $200 Ultra, and it's usage-based underneath, which trips up newcomers — though at roughly $0.07 per task in standard mode, it's cheaper in practice than the sticker suggests. Cursor isn't winning the raw autonomy benchmarks anymore (it lands mid-pack), but "the agent I'll actually keep open eight hours a day" is a different contest, and Cursor still wins it for a lot of people.
GitHub Copilot — The Default That Grew Up
Copilot is the safe institutional choice, and it's more of an agent than it used to be. It's multi-model now (everything from Haiku 4.5 up to Opus 4.8 and GPT-5.5), starts free, and scales to $10 Pro, $39 Pro+, and $100 Max metered in credits. The real upgrade is the cloud agent that turns a GitHub issue into a pull request via Actions — assign it, walk away, review the PR.
Where it shines is a well-tested codebase with clear issues and a team already standardized on GitHub. Where it lags is the hard, open-ended, "nobody wrote this down" work — it's tuned for low-to-medium complexity, and it shows. If your whole team already lives in GitHub, the low friction is worth a lot. If you're a solo operator chasing maximum capability, it's not the ceiling.
Google Antigravity — The Free Wildcard
Antigravity is Google's agent-first IDE, and the price is hard to argue with: free for individuals. It defaults to Gemini 3.5 Flash but will also run Claude Sonnet/Opus and open models, and it's built around an Agent Manager that fires off parallel subagents — plus real browser-use, so the agent can click around a live site while it works. On Terminal-Bench it's competitive (~76%).
The complaint you'll hear everywhere is rate limits — even paid users report getting throttled harder than expected, which is Google's way of paying for a free product. Treat it as a superb second agent: spin up parallel tasks at zero cost, and don't make it the tool your income depends on. (Note: the old standalone Gemini CLI free tier for individuals wound down in June and has folded into the Antigravity line — if you were on it, this is where you land now.)
The Open-Source Tier
If you value control and no lock-in over hand-holding, two names matter. OpenCode is the standout — MIT-licensed, model-agnostic across 75+ providers, with subagents and a headless server you can self-host, and 170K+ GitHub stars behind it. You bring your own API key and pay only for tokens. Aider remains the git-first terminal favorite: it edits your files and auto-commits each change, which makes rollbacks trivial. Neither will coddle you, but both put you fully in the driver's seat.
Devin — The Fully Autonomous Bet
Devin is the one that tries to be a teammate, not a tool. It runs autonomously in isolated cloud VMs, parcels work out to parallel managed agents, and reports a 67% PR merge rate on the tasks it takes. Pricing spans a free tier, $20 Pro, $200 Max, and Teams from $80/mo. When the task is well-specified and self-contained, it's genuinely fire-and-forget. When the task is vague or needs judgment, it wanders — so scope tightly and review everything before you merge.
So What Do You Actually Buy?
The operator's verdict
Most people should start with Claude Code on the $20 plan. It's the most capable agent here, and if your work is real, you'll feel the difference immediately. Upgrade to Max only when you hit the wall — you'll know.
Budget-conscious and multitasking? OpenAI Codex at $8–$20 is the best value, and Codex Cloud fits the way operators actually work.
Want to see every change before it lands? Cursor is still the nicest editor to spend all day in.
Your team lives in GitHub? Copilot's issue-to-PR flow is the lowest-friction path.
Want a free second agent for parallel work? Add Antigravity and pay nothing.
My actual setup: Claude Code as the workhorse, Codex as the cheap async second, and Antigravity kept around for free parallel tasks. Three agents, and the combined bill is less than one junior contractor for an afternoon.
The category is moving fast enough that this list will need a rewrite by winter. But the meta-lesson doesn't change: the models have converged, so stop shopping for the smartest model and start shopping for the harness that fits how you work. The only genuinely wrong move in late 2026 is coding without one of these open.