What Is an ADE, and Is It Really the Evolution of Developer UX?

“ADE” — Agentic Development Environment — is showing up in launch posts, analyst decks, and a lot of SEO content that all defines it slightly differently. The claim behind the term is big: that the IDE, a surface built around files and a cursor, is being replaced by something built around tasks, agents, and review.

I went looking for whether that claim survives contact with primary sources. The short version: the architectural shift is real and every serious vendor converged on the same primitives — but most of them refuse the vocabulary, and the two who use “ADE” do not even agree on what the A stands for. Which means the useful question for your team is not “should we adopt an ADE.” It is “which of these primitives does our repo actually need, and in what order.”

On August 12, 2026 I checked vendor primary sources (official blogs, changelogs, product docs, repository metadata) plus three independent research datasets. Product claims below are dated. Anything that is my read rather than a sourced fact is labeled editorial judgment.

Disclosure: I wrote this article inside Orca, one of the products discussed below. I have tried to treat it with the same skepticism as the rest, and everything I claim about it is checkable against its public docs and repository.

Audience: engineers and architects deciding how much of this category to adopt, and in what sequence.

TL;DR

• Two vendors own the acronym and disagree on its expansion. Warp says “Agentic Development Environment” (June 2025); Orca says “Agent Development Environment.” Cursor, Google, GitHub, AWS Kiro, and Factory all invented different vocabulary.
• Five primitives converged anyway, between June 2025 and February 2026: an orchestrator control plane, isolated parallel runtimes, spec-then-execute gates, artifact-level review, and a permission/audit layer.
• Some of the category has no model to sell. Orca is MIT-licensed and harness-neutral — you bring your own agent CLI and your own subscription — so its entire product is the orchestration layer. That is a claim made by architecture rather than by copy (editorial judgment).
• A whole tier refuses the framing. herdr (“the runtime your coding agents live on,” 28k stars) and cmux (“the terminal built for multitasking,” 26k stars) implement one primitive well and explicitly stay terminals. For most teams that tier is the right first purchase (editorial judgment).
• The real convergence nobody markets: herdr, cmux, and Orca all expose an API the agent itself calls, with a safety boundary. The human is no longer the only user of the UI — which is a better definition of the category than anything on the vendor sites.
• Two vendor-neutral standards came out of it — AGENTS.md (now under the Linux Foundation’s Agentic AI Foundation) and Zed’s Agent Client Protocol. Pure rebrands do not produce interop standards (editorial judgment).
• The evidence on payoff is genuinely mixed and getting harder to measure. METR measured experienced OSS developers as 19% slower in early 2025 while they believed they were 20% faster — then, on February 24, 2026, abandoned that study design because too many developers now refuse to work without AI. DORA 2025 found AI amplifies existing capability and still correlates negatively with delivery stability.
• Most developers are not there yet. In Stack Overflow’s 2025 survey, 52% either do not use agents or use only simpler AI tools, and 38% have no plans to adopt them.
• The defining features widen the security blast radius. Within a week of Google Antigravity’s launch, researchers demonstrated credential exfiltration via indirect prompt injection through a default-allowlisted browser subagent.

What You Will Learn Here

• Who actually uses the term “ADE” and who is being labeled with it — with a verification table
• The five primitives that define the category, each tied to a dated primary source
• The three tiers — multiplexer, orchestrator, platform — and which one your team should actually buy first
• What the UX shift actually is, past the marketing: reviewer and orchestrator instead of author
• The counter-evidence from METR, DORA, and Stack Overflow, without a side being picked for you
• A prerequisites checklist so you adopt primitives in an order that survives contact with your repo
• The failure modes, anchored in disclosed vulnerabilities rather than hypotheticals

1. Who Actually Says “ADE”?

This is the first thing worth checking, because almost every explainer on this topic skips it.

Two vendors own the phrase, and they expand it differently: Warp’s Agentic describes the environment’s character, Orca’s Agent describes who the environment is for. Orca is explicit about the second reading — “IDEs were built for you. An ADE is built for you and your agents.” Everyone else invented their own vocabulary entirely.

The definitional content circulating under the term mostly does not come from any of these vendors. It comes from third-party explainers and competitor SEO guides — useful as evidence that the term is being marketed, not as a definition to adopt.

Editorial judgment: the divergence matters more than the overlap. When a category is genuinely settled, competitors converge on vocabulary because buyers demand comparability. Here they converged on architecture and fragmented on names — which reads as real engineering under contested branding. An acronym whose own adopters disagree on the expansion is not yet a category; it is a bet on one.

2. The Five Primitives That Actually Converged

Strip the names away and the same five things show up in every one of these products.

 Intent            issue / prompt / spec (requirements, design, tasks)
                                   |
 Control plane     orchestrator: task lifecycle, dependencies, gates, triggers
                   (Warp Oz | Agent HQ | Cursor Agents Window | Orca Runs)
                                   |
       +-------------+-------------+-------------+--------------+
 Runtime | agent 1    | agent 2     | agent 3     | subagent fan-out
 Isolation| worktree  | container   | cloud VM    | remote SSH
                                   |
 Tooling           MCP servers | shell | browser | tests | CI
 Guardrails        allow/deny lists, approval gates, branch restrictions,
                   network egress allowlists
                                   |
 Review surface    diffs | artifacts (plans, screenshots, recordings) | PRs
 Observability     per-run link, transcript, audit trail, metrics
                                   |
 Human             reviewer / orchestrator — steer, comment, take over locally

2.1 A control plane that is not the editor

Cursor 2.0 (Oct 29, 2025) shipped multi-agent parallelism — up to eight agents at once, isolated by git worktrees or remote machines. Cursor 3.0 (Apr 2, 2026) made the split explicit: an Agents Window “centered around agents, while keeping the depth of a development environment,” running agents locally, in worktrees, in the cloud, and over remote SSH — and removed cloud agents from the Editor entirely.

Google Antigravity (Nov 18, 2025) shipped an Editor surface plus a Manager surface, describing the move as flipping “the paradigm of agents being embedded within surfaces to one where the surfaces are embedded into the agent.”

GitHub’s Agent HQ (Oct 28, 2025) is mission control across web, VS Code, mobile, and CLI, with third-party agents from Anthropic, OpenAI, Google, Cognition, and xAI. Agents run on your choice of compute — GitHub Actions or self-hosted runners — with “new branch controls that give you granular oversight over when to run CI and other checks for agent-created code.”

Warp’s Oz (Feb 10, 2026) is the most explicit control plane of the group: CLI, API, and SDK; Docker environments; a built-in scheduler; self-hosting; and support for “arbitrary orchestration patterns” such as team-leader/teammates topologies. Worth noting that Warp argued against cloud agents in its June 2025 ADE post (“cloud-based agents remove the human from the loop too early”) and then shipped exactly that eight months later.

Orca’s orchestration layer is the most formally specified of the ones I read, and it is worth describing precisely because it shows what “control plane” means once it stops being a marketing word. It models a Run (a durable namespace and coordinator inbox), Tasks with dependencies and a real status machine (pending, ready, dispatched, completed, failed, blocked), Dispatches (one attempt of a task on a terminal, holding lifecycle authority), typed Messages (worker_done, escalation, question, heartbeat), and decision gates that block a task until a coordinator resolves it.

Its docs are also explicit that a Run “never schedules or places workers” — placement and concurrency stay with the calling agent. Editorial judgment: that is a coordination substrate rather than an autopilot, and it is the same boundary GitHub draws by leaving compute choice to you. Both are worth noting because the marketing for this category generally implies the opposite.

If you want the orchestration patterns themselves rather than one vendor’s vocabulary, this repo covers them in building a senior-engineer agent that orchestrates subagents and when to use subagents vs the main chat thread.

2.2 Isolated parallel runtimes

Worktrees, containers, cloud VMs, remote SSH. Cursor isolates parallel agents with git worktrees or remote machines; Warp’s Oz uses Docker environments; Agent HQ runs agents on GitHub Actions or self-hosted runners with branch controls over agent-created code.

Orca is the clearest case of this primitive being load-bearing rather than optional — it describes itself as “worktree-native,” where every task gets its own on-disk checkout and its own branch, and each worktree scopes its own agent terminals, editor tabs, and browser tabs. Its docs are blunt about why: “this is what makes parallel agents safe — they never step on each other’s files.”

The detail most teams underestimate is what a clean checkout lacks. Orca solves it with three mechanisms worth stealing conceptually even if you never run Orca: shared paths that materialize from the primary checkout (APFS clone-copy where possible, otherwise a symlink), a repo-checked-in orca.yaml listing gitignored directories to share, and a .worktreeinclude file listing gitignored files to copy so each worktree owns its own.

# orca.yaml — shared, rebuildable, symlinked
worktree:
  sharedDirectories:
    - node_modules
    - .cache

# .worktreeinclude — copied, so each worktree owns its own
.env
.env.local
.vscode/settings.json

The distinction between the two files is the whole design: share what is large and rebuildable, copy what is small and per-worktree stateful. Symlinking .env across ten worktrees means one agent’s edit silently changes nine others.

That pattern is portable, and you do not need any product in this article to use it. The same thing in plain git:

#!/usr/bin/env bash
# new-agent-worktree.sh <branch>
set -euo pipefail
branch="$1"
root="$(git rev-parse --show-toplevel)"
dir="../$(basename "$root")-$branch"

git worktree add -b "$branch" "$dir" origin/main

# share: large, rebuildable, safe to alias
ln -s "$root/node_modules" "$dir/node_modules"

# copy: small, stateful, must not be shared
cp "$root/.env" "$dir/.env"

Fifteen lines of shell buys you the isolation primitive. The products in this article add lifecycle management, a UI, and a control plane on top — which is worth paying for at ten worktrees and probably not at two (editorial judgment).

If you want the mechanics rather than the category argument, this repo already covers them in depth in multi-repo feature folders with git worktrees and running agentic workspaces in the cloud at scale.

2.3 Spec-then-execute with approval gates

AWS Kiro, launched July 2025, generates three artifacts: requirements.md with EARS-notation (“Easy Approach to Requirements Syntax”) acceptance criteria, design.md with architecture and sequence diagrams, and tasks.md with dependency-sequenced work, with approval gates between phases. Its docs as of August 4, 2026 also describe a “Quick Spec” mode that skips those gates. GitHub shipped plan mode in VS Code alongside Agent HQ; Warp shipped planning mode in 2.0.

Again, the mechanics are covered here already: replacing plan mode with OpenSpec and getting started with GitHub Spec Kit.

2.4 Artifact-level review

This is the least discussed and, I think, the most consequential change (editorial judgment). Antigravity’s unit of review is an Artifact — a task list, a plan, a screenshot, a browser recording — not a diff. You comment on the artifact and the agent adjusts without halting. Google’s stated reasoning is worth quoting, because it is the clearest articulation of the problem this primitive exists to solve: “An agent being able to complete 80% of the work should be useful, but if there is no easy way to provide feedback, then it becomes more work than benefit to resolve the remaining 20%.” Warp’s Oz makes the same bet from the other direction, with agent-to-human handoff so you can continue the work locally.

Orca keeps the diff as the review unit but closes the loop differently: you drop Markdown comments on individual diff lines, batch them, and ship the batch back to the agent — with a documented worktree lifecycle of create, work, review, ship, archive, and inline PR creation and CI checks. It also surfaces authorship attribution on the diff, which matters once you cannot remember which of five agents wrote a given hunk.

Editorial judgment: these are two genuinely different bets. Artifact-level review scales better and catches intent errors; line-level review with batched comments catches implementation errors and keeps a human reading actual code. The second is slower and, given the security findings in section 7, probably safer today.

Either way, the reviewer is no longer the author. They are reading someone else’s work, at volume — which is a distinct skill, and one this repo has covered in how to build a good agentic code reviewer.

2.5 Permissions, audit, and cost

Allow/deny lists for shell commands and MCP servers, branch restrictions, network egress allowlists, per-run shareable links with full transcripts, audit trails, and metrics dashboards. Oz bills against both AI and compute usage, which turns agent spend into an observability problem most teams have no prior habits for (editorial judgment).

The one architectural question inside this primitive that actually decides your risk is who writes the allowlist and whether it defaults to allow or deny. A shipped default allowlist is a security boundary chosen by a vendor who has never seen your repo. Section 7 is what that looks like when it goes wrong: the exfiltration domain in the Antigravity disclosures was not a bypass of the allowlist, it was on it. If you adopt nothing else from this section, adopt default-deny with an egress list your team owns and reviews.

For the organizational side of this — who owns the boundaries and how they get enforced — see architecture governance for AI code generation.

3. The Counter-Position: Multiplexers, Not Environments

Everything above describes products that bundle the five primitives into one surface. There is a second, quieter movement that does the opposite — it takes one primitive, does it well, and explicitly refuses the “environment” framing. It is worth its own section because it is the strongest practical argument that you should buy primitives rather than categories.

herdr calls itself “the runtime your coding agents live on.” It is a single Rust binary, Apache-2.0 licensed, with 28,163 GitHub stars from a repository created March 27, 2026. It is a terminal multiplexer in the tmux lineage, with two additions that matter:

• Semantic agent state. It detects 19 agent CLIs out of the box and marks every pane working, blocked, or idle, rolled up to tabs and workspaces — so you stop opening panes to find out who is stuck.
• A server that owns the panes. Close the laptop, drop the network, or reboot: agents keep working and sessions come back, locally or over SSH.

Its positioning is a direct rejection of the bundle: “herdr doesn’t wrap them or replace them, it just owns their terminals.”

cmux is a native macOS terminal built on libghostty — Swift and AppKit, no Electron — with 25,974 stars from a repository created January 28, 2026. Its additions are vertical tabs showing branch, directory, and ports; notification rings that fire when a pane needs attention via standard OSC 9/99/777 escape sequences; a scriptable embedded browser; session restore that survives a reboot; and a socket API. Mitchell Hashimoto, who created Ghostty, described it as targeted at “people who use a ton of terminal-based agentic workflows.” Its own FAQ is blunt about scope: “cmux is a terminal, so any agent that runs in a terminal works out of the box.”

A naming aside that is on-thesis: there are two projects called cmux. Coder’s, shown on Hacker News in October 2025 as “Cmux — Coding Agent Multiplexer,” has since been renamed to coder/mux (“a desktop app for isolated, parallel agentic development,” AGPL-3.0, TypeScript). If you search for cmux you will find both. A category whose products keep colliding on names is a category still forming.

What the minimal tier proves

Note what these two do not have: no worktree lifecycle, no spec artifacts, no plan gates, no diff review surface, no merge policy. They implement the runtime and observability rows of the diagram in section 2 and nothing else.

And yet they converge with the maximal tier on one specific primitive — agents driving the environment itself through a documented control surface. herdr ships an agent skill file that activates only when HERDR_ENV=1 is set, with an explicit guardrail: if the variable is absent, the agent must stop and say it is not running inside a herdr-managed pane. Orca ships the same shape of thing as an installable skill over its CLI. cmux exposes every action over a Unix socket and publishes a skills collection.

Editorial judgment: this is the most interesting convergence in the whole category, and nobody markets it. Three products with completely different scopes independently concluded that the environment needs an API the agent itself calls — that the human is not the only user of the UI. That is a genuinely new idea in developer tooling, and it is a better definition of “agentic development environment” than anything on the vendor sites. If you want one test for whether a tool belongs in this category, use that: can an agent operate this tool as a first-class user, with a safety boundary that stops it from operating a session it does not own?

Editorial judgment: most teams asking “should we adopt an ADE” would be better served by the top row for a quarter. It is reversible, it costs nothing, and it tells you whether your actual bottleneck is visibility, isolation, or review — which determines whether the lower rows are worth their complexity.

4. The Strongest Argument That This Is Real: Interop

Marketing categories do not usually produce vendor-neutral standards. This one produced two.

AGENTS.md is a plain-Markdown instruction file for coding agents, originated across OpenAI, Sourcegraph’s Amp, Google Jules, Cursor, and Factory, and now stewarded by the Agentic AI Foundation under the Linux Foundation. InfoQ reported 20,000+ repositories in August 2025; the project itself advertises 60k+ examples on GitHub as of August 2026. OpenAI’s own monorepo carries 88 nested files — the format supports per-directory scoping.

ACP (Agent Client Protocol) is Zed’s JSON-RPC 2.0 protocol over stdio, explicitly modeled on the Language Server Protocol, decoupling the agent from the surface it runs in. Kiro advertises ACP compatibility. Where LSP made editors interchangeable for a given language, ACP is trying to make surfaces interchangeable for a given agent.

And then there is the third data point, which is the one that most complicates the cynical reading.

Orca is MIT-licensed and has no agent of its own to sell. It ships 25+ preconfigured CLI agents — Claude Code, Codex, Gemini, Copilot, OpenCode, Cursor CLI, Droid, Kiro, Amp, Goose and others — and takes the position that any CLI agent drops in. You bring your own subscription and your own harness.

Be careful with how much weight that carries. Orca is shipped by a company (Stably), and MIT-licensed open core is one of the most common commercial funnels in developer tooling — so “open source, therefore not marketing” would be a bad argument. Its GitHub repository passed 43,000 stars by August 12, 2026, from a repo created on March 17, 2026, but stars measure attention, not adoption or retention, and a fast star curve is exactly what a successful launch campaign looks like.

Editorial judgment, and this is the crux: the argument that survives is not the license and not the stars. It is harness-neutrality. A product with no model and no agent to bundle has nothing to upsell you into, which means its entire value proposition is the orchestration layer. A company betting its product on that alone is asserting that orchestration is a separable problem — and unlike a launch post, that claim is falsifiable. If the layer were not real, the product would be empty.

Put the three together — a file format competing vendors adopted, a wire protocol decoupling agent from surface, and products whose only value is the layer itself — and the pattern is a category solving for portability. That is not what capture looks like.

5. The UX Shift, Stated Honestly

The IDE optimized for one loop: read code → edit code → run code. Its primitives — cursor, file tree, autocomplete, breakpoint — all serve authoring.

The agentic surface optimizes a different loop: describe intent → dispatch → review → merge or steer. Its primitives are an agent list, a run transcript, a diff or artifact, an approval prompt, and a handoff button.

That last row is the whole argument (editorial judgment). Generation capacity went up sharply; review capacity did not move at all. Every primitive in section 2 — specs, artifacts, audit trails, plan gates — is an attempt to make review cheaper, because review is where the throughput dies. This repo has argued the same point from the human side in what is still human work.

6. The Counter-Evidence, Which Is Substantial

I am not going to resolve this for you. Here is what the independent data says. Several of these numbers appear in other articles in this devlog; what is new here is the February 2026 update, which changes how much weight the headline result can carry.

METR’s randomized controlled trial (July 10, 2025). Sixteen experienced open-source developers, 246 real tasks in repositories averaging 23,000 stars, using early-2025 frontier tooling (largely Cursor Pro with Claude 3.5/3.7). Developers forecast a 24% speedup and self-reported a 20% speedup afterward. They were measured 19% slower (confidence interval +2% to +39% on task duration). ML and economics experts had forecast 38–39% speedups.

METR’s follow-up, and why it matters more than the original (February 24, 2026). METR ran a second study from August 2025 with 57 developers, 143 repos, and 800+ tasks — then published it under the title “We are Changing our Developer Productivity Experiment Design.” Raw results showed an 18% speedup for returning developers (CI −38% to +9%) and 4% for newly recruited ones (CI −15% to +9%). Both intervals cross zero.

More importantly, METR declared its own data unreliable and is redesigning the study. The reason is the most interesting finding in this entire article: developers increasingly refuse to participate in the AI-disallowed condition. Between 30% and 50% told METR they withheld tasks specifically because they did not want to do them without AI. One participant put it directly: “my head’s going to explode if I try to do too much the old fashioned way because it’s like trying to get across the city walking when all of a sudden I was more used to taking an Uber.” METR’s own read is that developers are probably more sped up in early 2026 than in early 2025, but that their data is “only very weak evidence” for how much.

Editorial judgment: the honest summary is not “AI makes you slower” and not “the slowdown was disproved.” It is that the rigorous measurement got harder precisely because adoption got deeper, and the field currently has no clean controlled estimate of agentic tooling’s effect. Anyone quoting the 19% figure today without the February 2026 update — including this article’s first draft — is citing a result its own authors have moved on from.

DORA 2025 (September 23, 2025, ~5,000 respondents). AI is an amplifier of existing organizational capability, not a substitute for it: “AI doesn’t fix a team; it amplifies what’s already there.” Adoption is at 90% and 80%+ perceive productivity gains, yet 30% report little or no trust in AI-generated code. AI adoption now correlates positively with throughput but still negatively with delivery stability. Gains accrue to loosely coupled architectures with fast feedback loops, and not to tightly coupled slow ones.

Stack Overflow 2025 (49,000+ responses). 84% use or plan to use AI, but trust fell from 43% in 2024 to 33%, and the survey notes that “more developers actively distrust the accuracy of AI tools (46%) than trust it (33%).” On agents specifically: 52% either do not use agents or use only simpler AI tools, and 38% have no plans to adopt them. Among agent users, 69% report productivity gains but only 17% report improved team collaboration.

If you want to run this measurement inside your own repo rather than argue about other people’s numbers, from intuition to metrics is the practical version, and AI work paradoxes covers why faster tools frequently feel heavier.

Editorial judgment: put those together and the picture is that this category is being designed for a workflow that a majority of developers have not reached yet. That is not automatically wrong — tools sometimes lead practice — but it should temper the “the IDE is dead” framing considerably.

7. Failure Modes, Anchored in Real Disclosures

Within roughly a week of Antigravity’s November 18, 2025 launch:

• PromptArmor (Nov 25, 2025) demonstrated poisoned web content leading Gemini to read a .env file and exfiltrate AWS credentials through the browser subagent to a domain that was in Antigravity’s default allowlist. They documented three further exfiltration paths that did not require browser tools. In fairness to Google, PromptArmor states it did not undertake responsible disclosure, on the grounds that Google had already indicated awareness of data exfiltration risks.
• Johann Rehberger (Embrace The Red) documented five issues, including remote code execution via injection with an auto-execute bypass, MCP tool invocation without human-in-the-loop, and exfiltration through Markdown image rendering — several inherited from prior products and known since at least May 2025.
• Adam Swanda reported to Google on Nov 19, 2025 that the <EPHEMERAL_MESSAGE> system-prompt tag, which instructs the model to follow instructions without acknowledging them, actually strengthens injected payloads. Google classified it as intended behavior on Nov 20, 2025; he published the details on Nov 25, 2025.

Editorial judgment, and I want to be direct about it: the features that define an ADE are the same features that widen the prompt-injection blast radius. Unsupervised parallel agents mean nobody is watching in real time. Browser subagents mean untrusted content enters the context. Artifact-level review means a malicious line does not have to survive a human reading it. The UX promise and the security posture are in direct tension, and no vendor has resolved that yet.

Related reading in this repo: secure agentic code generation process.

8. What to Actually Do: An Adoption Order

Skip the category question. Adopt primitives in the order where each one makes the next one safe. This sequence is my synthesis of the DORA finding (gains require fast feedback and loose coupling) plus the vendor primitives above — treat the ordering as editorial judgment, the ingredients as sourced.

Stage 0 — prerequisites. Do not skip.

• Test suite fast and trustworthy enough that an agent’s green run means something
• CI that blocks merge on its own, without a human remembering to look
• Loosely coupled enough that two agents can work without colliding
• An AGENTS.md at the root, and nested ones for any directory with its own rules — see prompt-first repositories

Each stage below has an exit signal. If you cannot state the signal honestly, you are not done with that stage.

Stage 1 — one agent, visible. One agent, one task, full diff review. Move on when: you can predict, before dispatch, which task types this agent gets right in this repo.

Stage 2 — isolation. Worktrees or containers, so a failed run costs a rm -rf and not an afternoon. Move on when: throwing away a bad run requires no cleanup you have to think about.

Stage 3 — specs and gates. Plan-then-execute for anything above trivial. Move on when: the plan gate is catching real misunderstandings before code exists — if it never catches anything, it is theater.

Stage 4 — parallelism. Only after Stage 0 is genuinely true. Set your WIP limit by reviewer-hours, not by how many sessions you can afford. Move on when: your rate of merges that nobody really read is flat, not climbing.

Stage 5 — governance. Default-deny command and MCP allowlists, branch restrictions, egress allowlists, per-run audit links in every PR body, and a spend budget with an alert on it. Done when: you can answer “which agent changed this line, under whose approval, at what cost” without asking anyone.

The honest test at each stage: if your team cannot review the output of stage N reliably, stage N+1 will only produce more unreviewed code faster.

9. So Is It the Evolution of the UX?

My answer, clearly labeled as judgment: the architecture is a genuine evolution; the name is a land-grab that has not finished resolving.

What genuinely changed is that the developer’s primary interaction moved from authoring to dispatching and reviewing, and that shift needed new primitives — orchestration, isolation, specs, artifacts, audit — that an editor plus a chat sidebar cannot provide. Nine products converging on the same primitives inside twenty months, two vendor-neutral standards, and an unmarketed agreement that the environment needs an agent-callable API is not what pure marketing looks like.

But the noun is still unsettled, and the disagreement is informative. Warp’s “Agentic Development Environment” describes an environment that behaves agentically. Orca’s “Agent Development Environment” describes an environment built for agents as users. Those imply different products: the first wants to be smart on your behalf, the second wants to be a good host for whatever agent you bring.

That is the distinction to take into a vendor evaluation, and it is more useful than the acronym they share:

Neither column is the right answer for everyone. Bundles are faster to adopt and genuinely better if you do not want to make these decisions; substrates are cheaper to leave. Editorial judgment: in a category this young — where Warp reversed its own public position on cloud agents inside eight months, and two products still collide on the name “cmux” — optionality is worth more than polish.

What has not been established is that any of this makes teams faster. The one clean controlled study measured a slowdown, its authors have since abandoned that study design because developers will no longer work without AI, the largest survey shows a majority of developers not running agents at all, and the most-hyped product in the category leaked credentials in its first week.

Adopt the primitives, starting with the cheapest tier that fixes your actual bottleneck. Know whether you are buying a bundle or a substrate. Be skeptical of the noun.

Sources

• Introducing Warp 2.0: the Agentic Development Environment — Warp, June 2025
• Introducing Oz and Oz Platform overview — Warp, February 10, 2026
• Cursor 2.0 changelog — October 29, 2025
• Cursor 3.0 changelog and Agents Window docs — April 2, 2026
• Orca — product site, checked August 12, 2026
• Orca worktrees documentation — worktree-native model, shared paths, orca.yaml, .worktreeinclude
• Orca orchestration documentation — Runs, Tasks, Dispatches, Messages, decision gates
• Orca scheduled automations and skills registry & MCP
• stablyai/orca on GitHub — MIT license (copyright Lovecast Inc.); repository created March 17, 2026; 43,628 stars as of August 12, 2026
• herdr and herdrdev/herdr on GitHub — Apache-2.0, Rust; repository created March 27, 2026; 28,163 stars as of August 12, 2026
• herdr supported agents and herdr agent skill file — 19 detected agent CLIs; the HERDR_ENV=1 guardrail
• cmux and manaflow-ai/cmux on GitHub — Swift on libghostty; repository created January 28, 2026; 25,974 stars as of August 12, 2026
• coder/mux — AGPL-3.0; formerly coder/cmux, shown on Hacker News in October 2025 as “Cmux — Coding Agent Multiplexer”
• Introducing Google Antigravity — November 18, 2025
• Introducing Agent HQ — GitHub, October 28, 2025
• Introducing Kiro — AWS, July 2025, and Kiro specs documentation — last updated August 4, 2026
• Factory — “Agent-Native Software Development,” checked August 12, 2026
• AGENTS.md and InfoQ coverage of AGENTS.md adoption — August 2025
• Agent Client Protocol — Zed; JSON-RPC over stdio, modeled on LSP
• Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity — METR, July 10, 2025 (arXiv:2507.09089)
• We are Changing our Developer Productivity Experiment Design — METR, February 24, 2026 — the follow-up that supersedes the headline framing of the 2025 result
• Announcing the 2025 DORA report — Google Cloud, September 23, 2025
• Stack Overflow 2025 Developer Survey: AI
• Google Antigravity exfiltrates data — PromptArmor, November 25, 2025
• Security keeps Google Antigravity grounded — Embrace The Red, November 2025
• Indirect prompt injection in AI IDEs — Adam Swanda, November 2025