Every AI IDE is becoming the same shape

Spend a week each inside Cursor, Google Antigravity, and JetBrains Air, the way I just did, and something funny happens. The marketing could not sound more different, and the products keep feeling more alike. They're all converging on one shape: stop bolting a chat box onto a text editor, and start building the whole environment around an agent that does the work while you supervise it.

They arrived from opposite directions, which is the interesting part.

three products, one silhouette

Cursor came at it from the editor. It began as a very good VS Code fork with the sharpest autocomplete in the business, and grew an agent outward from there: Tab, then inline edits, then a Composer that works across files and runs commands.

Antigravity and JetBrains Air came at it from the far end. Antigravity, built from the Windsurf team Google absorbed, puts an Agent Manager at the center and treats the editor as one surface among several the agent reaches into. Air goes further and makes the unit of work a task: you describe it, an agent runs it in an isolated workspace like a git worktree or a container, and you review the result before it lands. Air was assembled on the corpse of Fleet, JetBrains' earlier editor that never left preview, and it shows: designed agent-first, not retrofitted.

The same silhouette from three starting points. Once you've noticed it, you can't unsee it.

the differentiators nobody demos

When every tool puts an agent at the center, the agent stops separating them.

Once everyone ships an agent, the agent is table stakes, and the contest moves to how well you supervise the one you've got.

So the features that distinguish these products are the dull, load-bearing ones nobody puts in a launch video:

• Supervision: running several agents at once without you becoming the bottleneck. Antigravity's Agent Manager is the current high-water mark.
• Isolation: where an agent's half-finished work lives so it can't wreck your tree. Air's task-per-workspace model, backed by worktrees and containers, is the cleanest I've used.
• Proof: how the agent shows you what it did. Antigravity's artifacts, the screenshots and plans and walkthroughs, set a bar the others have to clear.
• Lock-in: whose model you're quietly married to. This is where they split hardest.

That last one runs deeper than the demos let on. Cursor has moved toward its own in-house models for some features. Antigravity runs on Google's Gemini 3-class models, the entire point and the entire risk, since you're living in Google's world. Air took the opposite bet and stayed agent-agnostic, bridging Codex, Claude, Gemini, and its own Junie through ACP, the emerging standard for plugging agents into editors. If you care about not being locked to one vendor's brain, that choice is the whole ballgame.

the bet I got wrong

I'll own a bad call here. A couple of years back I was convinced the editor was the moat. I was a Cursor loyalist, told clients the autocomplete was the whole game, and believed whoever owned the best editing experience owned the category. Tab really was that good.

I misread where the value was moving. The editor became table stakes far faster than I expected. What's hard now isn't editing text, it's supervising work you didn't watch happen, keeping it isolated so a half-done agent can't wreck your tree, and trusting what the agent swears it did. The moat slid from keystrokes to oversight, and I spent a year staring at the wrong side of it.

what I think happens next

Here's my prediction, for what it's worth. The editor layer commoditizes, since they're all VS Code forks or Fleet-derived anyway and raw text-editing converges to good-enough across the board. The competition moves to the supervision layer: who runs the most parallel work with the least chaos, who isolates it safely, who proves what happened credibly, and who refuses to trap you on one model.

Air's agent-agnostic bet ages well if no single model stays on top forever, which I believe. Antigravity's Google bet needs Gemini at the frontier and a sane price to survive, two gambles at once.

If you track one thing across these tools, track how each handles work you are not personally watching. That's the real fault line, and where I keep updating my running read on the 2026 tools.

the part that stays human

Here's the one thing I don't think converges. All three race to run more work under less supervision, and each one assumes somebody already decided the work was worth doing. None of them decides what to build, or whether the ticket is even the right one, or when the honest reply to a feature request is no. They optimize the how. The what is still ours.

I've made my peace with that split. Let the agent open the browser, run the tests, and file the screenshots. I'll keep deciding which problems deserve an agent's time, and I suspect I'll be doing that long after these tools blur into one.