Agentic IDEs in 2026: 12 tools sorted by where your workspace lives

An agentic IDE is a development environment where the AI does more than complete the line you are typing: it plans a change, edits several files, runs commands, reads the output and corrects itself before it hands the result back. That is the whole difference to an autocompleter, and it is why the category got its own name in 2025.

The one question that actually decides which tool fits you is not "which model is smartest". It is: where does the workspace live — on your laptop, in a vendor's cloud sandbox, or on a server you can reach from any browser? Everything else (agent count, model choice, price) follows from that answer.

The three families

Most lists throw all twelve tools into one ranking. That hides the structural difference. Sorted by runtime, they fall into three families:

• (a) Desktop editors and VS Code forks. You install a program. The repository, the terminal and the agent run on your machine. Cursor, Windsurf, Kiro, Antigravity, Trae and Zed belong here.
• (b) Browser workspaces. Editor, terminal and agents run on a server; you open a tab. Claude Code on the web, OpenAI Codex (web) and UltraNOS belong here.
• (c) App builders. You describe an app and the service generates and hosts it. Replit, Bolt and Lovable market themselves this way.

The table only contains what each vendor states on its own start page (fetched 2026-09-08) or what is documented for UltraNOS. A dash means "not stated in the vendor's own copy", not "does not exist".

Tool	Family	Editor	Terminal	Multiple agents	Model choice	Where the workspace lives
Cursor	(a) Desktop	—	—	agents (stated)	—	your machine
Windsurf	(a) Desktop	—	—	—	—	your machine
Kiro	(a) Desktop	—	—	parallel agents (stated)	—	your machine
Antigravity	(a) Desktop	—	—	—	—	your machine
Trae	(a) Desktop	—	—	—	—	your machine
Zed	(a) Desktop	multiplayer editor (stated)	—	—	—	your machine
Claude Code (web)	(b) Browser	—	web ↔ terminal handoff (stated)	—	Anthropic	Anthropic's sandbox
OpenAI Codex	(b) Browser	—	—	—	OpenAI	OpenAI's cloud
UltraNOS	(b) Browser	Monaco	PTY over WebSocket	up to 16 parallel tasks	Claude, OpenAI-compatible, Ollama, own endpoint	server in Nuremberg
Replit	(c) Builder	—	—	—	—	Replit's cloud
Bolt	(c) Builder	—	—	—	—	Bolt's cloud
Lovable	(c) Builder	—	—	—	—	Lovable's cloud

The empty cells for the desktop family are deliberate. Cursor, Kiro and the others obviously ship an editor — they are editors — but their landing pages describe outcomes, not feature checklists, and this post only repeats what a vendor says about itself.

The twelve tools, one paragraph each

Cursor

Cursor describes itself as an "AI Coding Agent for Building Ambitious Software" and promises that "agents turn ideas into code" so you can "accelerate development by handing off tasks". That is the cleanest statement of the agentic model in the whole list: you delegate a task, the agent does the multi-file work. Cursor appears in every listicle on the first Google page (DataCamp, superset.sh, Builder.io), which makes it the de-facto reference point for family (a). It is a desktop application; the repository stays on your machine.

Windsurf

Windsurf returned HTTP 429 when we fetched its start page, so we cannot quote a self-description. What is known from the search results: DataCamp lists it among the dedicated agentic IDEs for 2026, next to Cursor and Kiro, and Google's related searches still show the older "Codeium web ide" query pointing here. Treat it as a desktop tool in family (a) and check the vendor's own page for the current feature set.

Kiro

Kiro frames its pitch as moving "beyond AI coding to agentic engineering". The start page names three concrete capabilities: "turn prompts into executable specs", "validate code correctness to find bugs unit tests miss", and "build across large codebases with parallel agents". The spec-first workflow is the differentiator here — the agent works from a written specification rather than a chat prompt. Kiro is the AWS entry in the category and belongs to the desktop family.

Antigravity

Antigravity is Google's entry. The page returned no readable content when fetched, so there is nothing to quote. From the search results: DataCamp lists "Google Antigravity" among the dedicated agentic IDEs of 2026. It is grouped with the desktop tools in that list. Nothing more can be said responsibly without the vendor's own copy.

Trae

Trae presents itself under the tagline "Collaborate with Intelligence" and says that it "integrates seamlessly into your workflow, collaborating with you to maximize performance and efficiency". The copy is about collaboration rather than delegation, which is a slightly different emphasis from Cursor's "hand off tasks". Google's related searches ("Trae AI", "Trae ide download") confirm two things: it is popular, and it is something you download, which puts it in family (a).

Zed

Zed is "a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter" and calls itself "your last next editor". Note what the self-description leads with: performance and multiplayer, not agents. It is the only tool in this list whose primary identity is "editor first, AI second", and both DataCamp and superset.sh still count it as agentic. Native, not a VS Code fork, desktop family.

Claude Code on the web

Anthropic's documentation describes Claude Code on the web as a way to "configure cloud environments, setup scripts, network access and Docker in Anthropic's sandbox" and to "move sessions between web and terminal with --cloud and --teleport". That is a browser workspace by definition: the agent runs in a sandbox Anthropic operates, and the session can be pulled back into your local terminal. The model is Anthropic's; there is no model choice. Family (b).

OpenAI Codex

OpenAI Codex refused the fetch with HTTP 403, so no self-description is available. From the search results and its position in the category, Codex is the OpenAI-hosted counterpart to Claude Code on the web: a cloud agent working on your repositories, with OpenAI models. Nothing about its feature set is claimed here beyond that placement in family (b).

Replit

Replit now calls itself an "AI App and Website Builder": "Describe what you want. Replit builds it. Get a working app or website in minutes. No coding required." Replit was a browser IDE for a decade; the current positioning is squarely family (c). It is worth stating plainly because "Replit" is what many people picture when they hear "web IDE", and that picture is out of date according to Replit's own copy.

Bolt

Bolt is a "Bolt AI builder: Websites, apps & prototypes" that lets you "build and scale high-performing websites & apps using your words". Same family as Replit: the input is a description, the output is a hosted app. There is no claim on the start page about an editor-plus-terminal workflow, so none is repeated here.

Lovable

Lovable answered with HTTP 403. What the search results show: Lovable-built apps surface for the query "agentic web ide" (one of them, a small project called SandnWaves, ranks for the phrase), which tells you Lovable's output is public web apps. It sits in family (c) with Bolt and Replit. No feature statements beyond that.

UltraNOS

UltraNOS is a browser workspace, family (b): Monaco editor, Git panel, a real PTY terminal over WebSocket, background agents that run tasks in a Think → Act → Check loop, and persistent memory across sessions. The AI comes from whichever provider you configure — Claude (API or CLI), any OpenAI-compatible endpoint, Ollama, or your own URL — with an 8-slot routing table so plan, code and commit messages can use different models. It is hosted at Hetzner in Nuremberg. It is not open source, not a VS Code fork, and self-hosting is available on request only. More below.

What "web IDE" actually means

Family (b) is the smallest group in this list and the one with the least established vocabulary. When we measured Google on 2026-09-08, the exact phrase "agentic web ide" returned mostly small projects — a Soroban tool, a Lovable app, a GitHub profile. The term is unoccupied. That does not mean the category is unimportant; it means the listicles are written by people with a desktop mental model.

What you get from a browser workspace:

• Any device. A Chromebook, a locked-down corporate laptop, a tablet, a phone with a keyboard. Nothing to install, nothing that needs admin rights.
• The workspace outlives the laptop. Repository, terminal state, running agents and chat history live on the server. Close the lid, open a different machine, continue.
• Agents keep working while you are gone. A task started at 17:00 does not stop because you shut the laptop.
• Compute is not your battery. Builds, test suites and long agent loops run on the server.

What you give up:

• You need a network. No connection, no IDE. Not "degraded", none.
• You need to trust the operator. Your code and your prompts pass through someone else's server. That is an organisational decision, not a technical one — read the AV contract, check the server location, ask what gets logged.
• Latency in the editor. Every keystroke does not go over the wire (Monaco runs in the browser), but file saves, terminal I/O and Git do.

Claude Code on the web and Codex solve the trust question by being the model vendor themselves. UltraNOS solves it differently: the workspace operator and the model vendor are separate, and you pick the latter. For a longer treatment see what an agentic web IDE is.

Eight criteria — a checklist

Print this, tick what you actually need, then filter the table by it.

1. Editor. Do you want a real editor with tabs, diagnostics and jump-to-line, or is a diff view enough because the agent writes everything?
2. Terminal. Can you run arbitrary commands in the same environment the agent uses? A shared shell is where most debugging happens.
3. Git. Stage, commit, branch, push from inside the tool — or do you switch to another window?
4. Multiple agents. Can one task spawn sub-agents that run in parallel, and can you watch and stop each one?
5. Tool approvals. Does the tool ask before it runs rm -rf or a force push, and can you approve a class of actions once instead of every time?
6. Cost and loop brake. What stops an agent that calls the same tool with the same result for the fifth time, or one that has been running for 45 minutes?
7. Memory. Does the tool remember decisions from last week, or does every session start blank?
8. Secret protection. What happens to an API key that ends up in a prompt, a pasted .env or a shell output the agent reads?

Vendors rarely document points 5 to 8 on their start page. Those are the questions to ask in a trial, and they are the ones that decide whether an agent is safe to leave running.

UltraNOS, honestly sorted

Against the eight criteria, this is what UltraNOS can point to in its own documentation:

Criterion	UltraNOS
Editor	Monaco with tabs, dirty markers, lint diagnostics (ruff + JS), inline ghost-text completion
Terminal	PTY in the browser, 8 terminals per tenant, output throttled at 512 KB/s
Git	Status, stage, commit, push, branches, stash, partial clone by default; own Git server (UltraForge) with issues and pull requests
Multiple agents	spawn_agent from chat, live fleet view, depth limit 2, at most 16 concurrent tasks
Tool approvals	Approval dialog for unsafe tools, batch approval, built-in guards (no-rm-rf, no-force-push, no-drop-table, no-curl-pipe-bash) plus your own regex
Cost / loop brake	Loop watch: third identical call gets a warning, fifth is refused; oscillation A↔B detected; 45-minute budget per turn; automatic retry with backoff per provider
Memory	Persistent memory across sessions (Centre AI), per-session context limit with summarisation
Secret protection	cloak: API keys, passwords and e-mail addresses are replaced by placeholders such as CLOAK_SECRET_… before the request leaves for the provider

Three honest limits on that last row. cloak is pattern-based: a secret without a known prefix, an assignment context or high entropy passes through. On the Claude CLI path only the prompt and the system prompt are redacted; the CLI runs its own tools and their output does not pass through cloak. And the built-in transparency view that would show you every replacement per turn exists but is not yet wired to a producer, so the only proof today is the cloak field in GET /api/health on the hosted instance, which reports profile enforce. Details in redacting API keys before they reach an LLM.

What UltraNOS is not: not open source (the repository is private), not a VS Code fork, not a desktop app (there is an Android app), and not a model vendor — the AI is whatever provider you configure. Self-hosting is optional and on request. Prices: Starter 0 €, Pro 19 €/month, Team 49 €/month, with a 14-day trial.

Decision tree in five questions

1. Do you need to work offline, or on a machine you fully control? Yes → family (a). Pick Zed if you want a native editor, Cursor or Kiro if you want the agent to lead.
2. Do you want a running app rather than a codebase? Yes → family (c). Replit, Bolt or Lovable; the output is hosted for you.
3. Are you already committed to one model vendor? Yes and it is Anthropic → Claude Code on the web. Yes and it is OpenAI → Codex.
4. Do you want to choose or switch models, or run a local model through Ollama? Yes → UltraNOS, or a desktop tool that supports your provider (check the vendor's page; we could not verify this from their copy).
5. Do agents need to keep running after you close the laptop, and do you work from several devices? Yes → family (b). No → family (a) is simpler and has more tooling around it.

If you answered "yes" to 1 and to 5 you have a genuine conflict. There is no tool in this list that runs offline and keeps agents alive on a server. The nearest thing is Claude Code's web ↔ terminal handoff.

FAQ

What is an agentic IDE?

A development environment where the AI plans a change, edits multiple files, executes commands and checks its own result, instead of completing the current line. The Builder.io definition — an AI that "lives in the project instead of next to it" — is the shortest version. The agentsroom.dev definition adds multi-agent, multi-provider and shared context as the distinguishing marks.

Which agentic IDE is the best?

It depends on the family. For a desktop editor with the agent in the lead, Cursor and Kiro are the ones every list names. For a native editor, Zed. For a browser workspace tied to one vendor, Claude Code on the web or Codex. For a browser workspace with free model choice, UltraNOS is the option in this list. Nobody can honestly rank across families, because the runtime decision comes first.

Is there a free agentic IDE?

Several tools have free tiers; the vendor pages fetched for this post do not state their prices, so check them directly. UltraNOS has a Starter plan at 0 € and a 14-day trial of the paid plans. Note that a free IDE tier and free model usage are different things: in most tools the model calls are the actual cost.

Do I need my own API key?

For the vendor-bound tools (Claude Code on the web, Codex) you need an account with that vendor. For UltraNOS you can bring your own key for Claude, an OpenAI-compatible service or Ollama, or use the operator-provided access on the paid plans. For the desktop tools, check the vendor — most bundle model access into the subscription, but we could not verify this from their start pages.

Does a web IDE work offline?

No. A browser workspace needs a connection to the server where the editor state, terminal and agents run. If offline work is a hard requirement, only family (a) fits. What a web IDE does instead is keep working when you are offline: agents started in the browser continue on the server.

Who this comparison is not for

If you write code on one machine, in one editor, and mostly want better autocompletion, you do not need an agentic IDE at all — a completion plugin in your current editor is cheaper and less disruptive. If your organisation forbids source code leaving the laptop, the entire browser family is out and this list reduces to six tools. And if you are choosing between two desktop editors, the vendor pages will tell you more than this post can, because we only repeated what they say and deliberately did not guess the rest. The German version of this comparison is at agentische IDEs im Vergleich.

Your keys stay yours — the rest runs in the browser.

UltraNOS is the agentic web IDE: parallel AI agents, editor, git and terminal. cloak replaces API keys and passwords before a prompt reaches the provider. Hosted in Germany, 14 days free.

Try 14 days free →