What is an agentic IDE?

"AI IDE" now covers two different paradigms. The first generation, chat IDEs like Cursor, Windsurf, and GitHub Copilot, puts a model inside your editor. You prompt it in a file or a side panel, it proposes code, and you accept or reject as you go. These tools are genuinely good at what they do: they make writing code faster.

But they keep you as the orchestrator. Every suggestion passes through your hands, one session at a time, and the structure of the work, what to build, in what order, on which branch, stays in your head.

An agentic IDE inverts the relationship. The input is a task, not a prompt; the output is a reviewable unit of work, not a completion. The agent reads the codebase, writes a plan, works on its own branch, implements the change, can run tests along the way, and hands back a pull request. Your job shifts from typing to reviewing.

The parallelism row is where the two paradigms diverge most. Because an agentic IDE isolates every task on its own branch, nothing stops you from running several tasks at once, a multi-agent coding environment, where three or four stories progress while you review a fifth. A chat session, by contrast, occupies you for its whole duration.

Neither model makes the other obsolete. Chat IDEs remain the right tool for exploratory edits and changes too fuzzy to specify upfront. Agentic IDEs win when the work is well-defined enough to hand off, which, on a mature codebase, is most of it. For the longer argument about why reviewing outcomes scales where prompt-and-accept doesn't, see engineering with AI agents.

The clearest way to define the category is to walk the loop end-to-end. Here is how a task moves through AIDEN, the pattern most agentic tools converge on, with local variations.

One thing happens before any task runs: AIDEN reads the whole project and builds a technical and business overview. Every agent starts from that shared context, the structure, the conventions, the test setup, what the product actually does, instead of rediscovering it per prompt or guessing.

1. 1

   Write a story on the board

   Work starts as a card in the Stories column of a kanban board: the goal, acceptance criteria, and any constraints. The board, Stories, Spec Review, In Progress, Review, Done, is the control surface for everything that follows.
2. 2

   AI drafts a spec, you approve it

   The story moves to Spec Review, where an agent drafts an implementation plan: files to touch, approach, edge cases. Nothing runs until you approve it, an enforced gate in AIDEN since v1.5.21. Catching a misunderstanding at the plan stage costs a minute; catching it in a 40-file diff costs an afternoon. More on why in spec-driven AI development.
3. 3

   The agent gets an isolated branch

   On approval, AIDEN creates a dedicated git branch or worktree for the story. This is the mechanism that makes parallelism safe: agents on separate worktrees cannot clobber each other or your working copy. How that works under the hood is covered in parallel agents with git worktrees.
4. 4

   Implement, test, iterate

   The agent, your local Claude Code or Codex CLI, driven by AIDEN, implements the spec on its branch. It can run your test suite and iterate on failures as it goes. This is best-effort, not a guarantee: agents still produce broken code sometimes, which is exactly why the next two steps exist.
5. 5

   An optional LLM review pass

   Before the diff reaches you, AIDEN can run a second model over it as a reviewer, flagging logic errors, missed acceptance criteria, and style drift. It catches the cheap mistakes so your human review focuses on design. See the AI PR automation workflow for how this stage fits together.
6. 6

   One-click PR, human review

   From the story card, one click opens a pull request with the spec attached as context. You review the diff, request changes, or merge. The story moves to Done, and the branch history shows exactly what happened.

This scaffolding, context, gates, isolation, review, is what turns a raw coding agent into something you can trust with real work. We call the full set of conventions the agent harness. And because each loop is isolated, running three or five at once is the same workflow, not a new one, the shape of that is covered in the multi-agent coding workflow.

Plenty of tools now market themselves as "agentic." Some are chat IDEs with a run button. When you evaluate one, these six capabilities are the substance behind the label.

A useful test when a vendor demos their tool: ask what happens when two agents touch the same file, and ask what the agent knows before it starts writing. The first answer tells you whether isolation is real; the second tells you whether the plan is a reviewable artifact or a hidden chain of thought.

The category has settled into four shapes. Desktop orchestrators like AIDEN run agents locally on top of your own CLIs. VS Code forks like Cursor, Windsurf, and Kiro add agent modes to a familiar editor. Cloud agents like Devin and GitHub's Copilot coding agent run tasks entirely on hosted infrastructure. And open-source extensions like Cline bring agentic loops into the editor you already use.

They differ mainly on three axes: where your code lives, how many agents can run at once, and who holds the API keys. This page defines the category; for the ranked list with honest trade-offs, see the best agentic IDEs in 2026. For head-to-head detail, start with AIDEN vs Cursor, AIDEN vs Windsurf, and AIDEN vs Devin.

AIDEN is a desktop orchestrator that runs on top of your local Claude Code and/or Codex CLI: AIDEN handles the workflow, boards, branches, specs, agents, while the CLIs handle the model calls. Setup looks like this.

1. 1

   Install at least one agent CLI

   AIDEN requires Claude Code (Anthropic) or Codex CLI (OpenAI) installed locally. It works with either, and better with both, you can pick the engine per story. Your keys stay in ~/.claude and ~/.codex; AIDEN never reads, copies, or transmits them.

   npm install -g @anthropic-ai/claude-code
   # and/or
   npm install -g @openai/codex

2. 2

   Download AIDEN for macOS

   Grab the .dmg from aidenapp.org and drag it to Applications. AIDEN runs on macOS 12+ (Apple Silicon and Intel, signed and notarized). Windows and Linux desktop apps are on a waitlist, though the self-host server mode ships a Linux installer and Docker image today.
3. 3

   Open a project

   Point AIDEN at a local git repository. It analyzes the codebase into a technical and business overview, detects your installed CLIs, and inherits your Claude Code MCP setup automatically. If you already juggle multiple Claude Code terminals, this is the step where Claude Code orchestration replaces the tab pile.
4. 4

   Ship your first story

   Create a story, review and approve the drafted spec, and watch the card move across In Progress → Review → Done. You can even delegate a task hands-free with the voice orchestrator, push-to-talk with Cmd/Ctrl+Shift+V. When the agent finishes, the PR is one click away.

The Free plan covers one project with no credit card. Solo is $19/month (or $169 lifetime, limited launch round), and Team is $10 per seat per month with a 3-seat minimum.