What Is an Agentic Development Environment (ADE)? Definition, Examples, Open-Source Options

An agentic development environment (ADE) is a workspace built around AI coding agents, with the code editor as one panel among several. You hand agents tasks; they plan, edit files and run commands on their own, often several at once in isolated copies of the repository; and you review, steer and merge what they produce.

In an IDE you write the code and the AI helps. In an ADE the agents write the code and you run them. That one change turns typing into delegating, watching and reviewing, and a new kind of tool has grown up around it.

Where we stand. We build OpenChamber, which describes itself as an open-source agentic development environment, so we are not a neutral party. OpenChamber sits in the comparison on the same terms as everyone else, including the rows where others are ahead of us. Every product claim in the table was checked against the vendor’s own site or repository on 9 November 2026.

The short version

Where the term came from

Warp introduced the phrase in June 2025, when it launched Warp 2.0 as “the first Agentic Development Environment”. Its definition covers a terminal, IDE or CLI built around AI coding agents as first-class participants. The agent reads the whole codebase, runs commands, keeps a reviewable record of what it did, and hands control back to a person cleanly. The same page adds two requirements: running several agent harnesses, and verifying its own work, ideally with computer use.

By 2026 the term had spread well beyond Warp, and its meaning widened with it. Augment Code’s guide to ADEs, first published in March 2026, describes them as tools for agent orchestration, with several agents working in parallel as a basic feature, and names its own product Intent as one. JetBrains previewed Air in March 2026 under the same label, as a tool for delegating tasks to several agents at once, each isolated in a container or a git worktree.

The wording varies. Warp’s footer and GitHub repository say “agentic development environment”. Its homepage leads with “open infrastructure for cloud software factories” and calls Warp “an open agentic development platform” further down. Google calls Antigravity “our agentic development platform”. Orca says “the agent development environment” on its site. The words differ, and they describe the same shift: tools built around agents first, with the editor as one panel among several.

By the autumn of 2026 the paid end of the category was moving to teams and the cloud. Warp’s own definition now draws that line: “An ADE is where an individual developer works with an agent. A software factory is what an organization builds when it wants that same agentic work to run reliably, on its own trigger, across many repos and many developers.” Emdash launched a cloud product for teams on 5 November and renamed its desktop app Emdash Classic. JetBrains moved Air into its IDEs and a cloud service called Air Teams. Paradev and cmux charge for cloud machines that run agents, on top of a free desktop app. For one developer on one laptop, most ADEs are still free.

ADE vs IDE vs CLI agent vs cloud agent

The four categories overlap, and most products sit in more than one. The useful question is what each one puts at the centre.

The line between an ADE and a CLI agent is the easiest to blur. Claude Code or Codex on its own is an agent harness: the program that drives a model, calls tools and edits files. Most ADEs run that program, often several copies of it at once, and add what one terminal window lacks: isolation between tasks, a place to review, a record of what happened, and a way to keep going when you close the laptop.

The tools on either side of the table are moving toward the ADE column too. VS Code now has an Agents window for delegating tasks across projects and running them in parallel. The Claude Code desktop app runs several sessions side by side, each in its own git worktree if you turn that on, with a diff view for review. Neither vendor calls its product an ADE.

What an ADE has to do: eight checks

These eight questions are drawn from Warp’s and Augment’s definitions and from what users of these tools complain about. Each one can be checked in an afternoon.

1. Does it run more than one agent? Some ADEs run any CLI agent you have installed; others run one harness with many models behind it. Neither is wrong, but you should know which you are buying. Check: can you start a Claude Code task and a Codex task side by side?
2. Does it isolate parallel work? Two agents editing the same checkout will overwrite each other. The usual answer is a git worktree per task, a separate branch in a separate folder; some tools use containers or cloud sandboxes. Check: start two tasks on the same repo and see whether their files ever touch.
3. Can you review before anything merges? A diff per task, comments, a way to reject or roll back. Check: how many clicks from “the agent says it is done” to “I have read every changed line”.
4. Is there a record of what the agent did? Commands run, files changed, tools called, and who approved what. Check: find the exact command an agent ran an hour ago.
5. Are permissions explicit? What can the agent do without asking, and what needs a yes? Check: what happens when an agent needs approval while nobody is watching.
6. Does the work survive you walking away? Sessions that keep running on a server, reconnect from another machine, or reach your phone. Check: start a long task, close the laptop, and pick it up somewhere else.
7. Can you see what it costs? Usage and quota per provider, ideally before you hit the wall. Check: how much of this week’s plan did today’s tasks take.
8. Can you take over mid-task? Jump into the same session, edit by hand, hand it back, without losing context. Check: interrupt a running task and finish it yourself.

Who builds ADEs in 2026

Every product in the table either calls itself an ADE or is built for running several coding agents in parallel, which is what the term now describes. “How it describes itself” is the vendor’s own wording, quoted from its site or repository. Stars are GitHub stars on 9 November 2026.

Conductor runs Claude Code, Codex, Cursor and OpenCode in parallel on a Mac, but on 4 November 2026 it announced that it is joining Meta. New sign-ups are closed, Conductor Cloud goes read-only on 13 November and shuts down on 20 November, and the local app gets new models and critical bug fixes until early 2027. If you use it today, plan a move before then.

Open-source ADEs

If you want to read the code or run it on your own hardware, 11 of the 13 products in the table publish their source under a licence that allows it:

• Orca. MIT. The largest community by a wide margin, with 119.7k stars and 27 named agents plus any other CLI agent.
• T3 Code. MIT, free, and the second-largest community at 53k stars. The web and phone apps drive agents that run on your own computer or server.
• Paradev. MIT since 4 November 2026; before that it was Superset, under the Elastic License. Free for one user with local workspaces; remote access, the mobile app and cloud workspaces are on paid plans.
• OpenChamber. MIT. Desktop on all three operating systems, browser, VS Code and phone, around one harness, OpenCode.
• Herdr. Apache 2.0. A native app and a terminal interface for any CLI agent, and the agents keep running after you close it.
• Emdash. Apache 2.0. The desktop app, now called Emdash Classic, runs on all three operating systems with remote work over SSH. It still gets fixes, and new features go into the cloud Emdash 2.0.
• Paseo. Apache 2.0. A daemon you can run on a server, with native mobile apps.
• Intent. Apache 2.0. A free desktop app with a built-in coordinator agent that plans work and hands it to your CLI agents.
• Agentty. Apache 2.0. A terminal interface for people who do not want a desktop app.
• cmux. GPL-3.0. A macOS terminal built on Ghostty for running many agents at once, with paid cloud VMs on top.
• Warp. AGPL-3.0, with its UI framework under MIT. The cloud factories are billed by usage.

What breaks when you move to an ADE

An ADE solves the problem of running one agent at a time. It creates new problems of its own, and the users who already work this way describe them clearly.

The bill becomes the main complaint. In our analysis of 66,320 Reddit complaint posts, excessive token consumption rose from ninth place to third in a year, from 9.1% to 13.7% of complaint posts. The posts are mostly about control: which model got picked, how much context was re-sent, how many subagents were spawned. Run five agents at once and that question comes up five times as often, which is why check 7 matters.

Review becomes the bottleneck. Code that arrives faster than anyone can read it turns into code that somebody has to maintain. In the same data Cursor shows this most clearly: its three security categories added nearly 14 points in a year, alongside a rise in complaints about maintaining what the agent wrote. Across the market, security risk from running the agent grew 2.4 times, from 1.2% to 2.9% of complaint posts.

Unattended runs stall in new places. The complaints that did not fit last year’s categories describe a world of parallel agents: subagent fan-out, permission prompts in the middle of long unattended runs, and credit accounting across several plans at once. All three get worse as you add agents, and all three are covered by checks 5, 6 and 7.

Parallel work collides. Two agents on the same files, or two branches that each pass on their own and conflict when merged. Isolation per task, check 2, prevents the first. Nothing prevents the second except reviewing and merging in a sensible order.

How to evaluate an ADE in an afternoon

Pick a real task from your backlog that splits into three independent pieces, then run it end to end in the tool you are considering.

1. Start the three pieces as separate tasks, in parallel, each in its own isolated copy of the repo.
2. While they run, note how easy it is to see which one is stuck, which one is waiting for you, and which one is done.
3. Leave the machine for half an hour. Come back from another device if the tool allows it.
4. Review each result before it merges. Count how long it takes to read every changed line.
5. Merge all three and see what conflicts.
6. Check the usage view: what did the afternoon cost, and against which plan.
7. Interrupt one task midway and finish it by hand.

The tool that wins this test is the one you will still be using in a month. Feature lists matter less than how the tool behaves on a task that goes slightly wrong.

Where OpenChamber fits

OpenChamber is an open-source ADE built around one harness, OpenCode, with models from any provider OpenCode supports. It runs as a desktop app on macOS, Windows and Linux, in a browser, in VS Code, and on iOS and Android, both in beta.

Where it is strong:

• work that survives you leaving, with remote instances over SSH and phone access through a private relay;
• isolated worktree sessions, and multi-run for trying one task on several models;
• usage and quotas per provider in one place, with an optional switch to the next account or a fallback model when a limit stops a session;
• pull request review inside the diff, for GitHub, GitLab, Gitea, Forgejo and Gerrit;
• session goals that keep an agent working toward a finish line, with an independent check after every turn;
• scheduled tasks.

Where others are ahead: Orca, Paseo, Emdash, T3 Code and Herdr run Claude Code, Codex and other agents as sessions of their own, side by side. OpenChamber brings models in through OpenCode. Claude, for example, comes through OpenCode’s built-in Claude Agent provider on your Claude subscription. If you want each agent’s own interface and behaviour, that is a real difference. The iPhone app is still in TestFlight, and Orca’s community is about nine times larger.

Most of the work in an ADE today is code. The loop it supports is the same for research, specifications and the rest of product work: plan, delegate, watch, review, merge. That is the direction we are building in.

FAQ

What is an agentic development environment?

A workspace where AI coding agents do most of the work, often several at once, and a person directs, reviews and merges what they produce. The agents plan, edit files and run commands on their own; the environment keeps their work isolated, visible and reviewable.

Who coined the term ADE?

Warp, in June 2025, when it launched Warp 2.0 as “the first Agentic Development Environment”. The term has since been adopted by Orca, Paseo, Emdash, Agentty, OpenChamber and JetBrains Air, among others. Warp still uses it in its footer and on GitHub, and its homepage now leads with cloud software factories.

What is the difference between an ADE and an IDE?

An IDE is built around a code editor, and the AI helps you write. An ADE is built around agents, and you direct and review their work. Many ADEs include an editor, and many IDEs now include agents; the difference is what sits at the centre.

Is Cursor an ADE?

Cursor started as an AI-native editor. Its homepage now says “Cursor is your coding agent for building ambitious software”, it has an agent-first interface, and it runs cloud agents on their own virtual machines. Whether it works as an ADE for you depends on which of those you use it from. Orca, Paradev and T3 Code can also run the Cursor agent as one of several.

Is Claude Code an ADE?

The Claude Code CLI is an agent harness: the program that drives the model and edits your files. The Claude Code desktop app goes further and runs several sessions in parallel, each in its own git worktree if you turn that on, with a diff view for review. Anthropic calls neither of them an ADE. Orca, Paseo, Emdash, T3 Code, Herdr and Paradev run Claude Code inside them, often several sessions at once.

Are there open-source ADEs?

Yes. Orca, T3 Code, Paradev and OpenChamber are MIT-licensed; Herdr, Emdash, Paseo, Intent and Agentty are Apache 2.0; cmux is GPL-3.0; Warp is AGPL-3.0.

Is an ADE only for writing code?

Code is where agents are most capable today, so it is where ADEs started. The same way of working applies to research, specifications and analysis: hand off a task, let it run, review the result. ADEs are starting to be used for those too.