- Hermes IDE: Download free · Star it on GitHub — one console for every coding agent, on macOS, Windows and Linux
- Book: AI Agents Pocket Guide · AI in TypeScript — the 5-book series
- Me: xgabriel.com | GitHub
Every tool in this post can run several coding agents at once,
each on its own git branch in its own worktree. They split on four
other things: which agents you can run, how you hear that one is
stuck, how you review and land its work, and what it costs on top
of the agent subscriptions you already pay for.
The "stuck" part gets underrated. An agent that sat for twenty
minutes on "Allow this command?" while you read another diff did
twenty minutes of nothing.
Disclosure up front: I build Hermes IDE. I have not benchmarked
Cursor, Warp or Zed for this post. Everything about those three
comes from their own docs, changelogs and download pages, which I
read on 12 October 2026, and every cell in the tables links to its
source. Where their docs didn't cover something, the table says
"not in the docs I read (Oct 2026)" rather than "no". A missing
line in a docs page is not proof a feature is missing, so if you
know better, tell me (the link is at the end).
One more note, because the name trips people up: Hermes IDE is not
affiliated with Nous Research or its Hermes Agent (which Hermes IDE
can run).
Real Hermes window, test build with stand-in agents: one task running in Claude Code and Codex side by side, each on its own branch.
Worktrees are table stakes now
Run two agents in one checkout and they overwrite each other's
files. The fix everyone settled on is the same: one git worktree
and one branch per task, so each agent edits its own copy of the
repo.
Underneath every tool in this post, that comes down to plain git:
git worktree add -b task/fix-login ../repo-fix-login
git worktree add -b task/add-tests ../repo-add-tests
git worktree list
Cursor does it (worktrees docs).
Warp does it (multi-agent guide).
Zed does it per thread (Parallel Agents).
Hermes does it on every task you start from ⌘N (Ctrl+Shift+N on
Windows and Linux), on a branch named hermes/<task>
(README). So do
the GitHub Copilot app, Claude Code desktop, Codex in the ChatGPT
desktop app, JetBrains Air, Devin Desktop (formerly Windsurf) and
Conductor, with sources in the "Also worth knowing" table below.
Since all of them isolate the work the same way, the rest of this
post leaves isolation alone and compares the other four things.
The four tools, side by side
Bracketed codes link to the source page, and the full list sits
under each table. H1 and H2 are the Hermes README and release
notes. The Hermes column runs longer in places because I know it
from the inside. That doesn't mean the others do less. Prices are
as listed on 12 October 2026, so recheck before you budget.
What you can run, and how it runs
| Cursor | Warp | Zed | Hermes IDE | |
|---|---|---|---|---|
| Agents you can run | Cursor's agent with models from Anthropic, OpenAI, Google, xAI, Cursor's own Composer and others [C1] | Warp Agent, plus CLI agents: Claude Code, Codex, OpenCode, Gemini CLI, Amp, Pi, Droid; Kiro CLI added 2026-10-07 [W1] [W2] | ACP agents (Claude Agent, Codex, OpenCode, Copilot, Cursor, Pi, Gemini CLI, Poolside, "curated, not exhaustive") [Z1], and any terminal agent via Terminal Threads [Z2] | Claude Code, Codex, Antigravity CLI, Gemini CLI, GitHub Copilot CLI, OpenCode, goose, Aider, Kiro CLI, Hermes Agent, any custom CLI agent [H1] |
| How an agent shows up | Agents Window with Agent Tabs, side by side or in a grid; switch back to the IDE anytime [C2]; Remote Control of local agents from the iOS app [C5] | CLI agents in tabs or panes; vertical tabs carry branch, worktree and PR info [W1] [W3] | Threads in a sidebar, all in one window; a CLI like claude becomes a managed thread [Z2] [Z3]
|
Each agent's own interface in a real terminal; optional Agent view for Claude [H1] |
| Isolation | Worktrees (25 kept per machine by default), cloud VMs, remote SSH, self-hosted machines [C3] [C2] [C5] | Own worktree and branch per agent [W1] | Worktree isolation chosen per thread; per-thread folder access [Z3] | Worktree and hermes/<task> branch per task; dependencies ready in seconds when they match the main checkout; separate ports for parallel dev servers [H1]
|
| Cloud agents | Yes, isolated cloud VMs, charged at API pricing with a spend limit [C4] | Yes, /orchestrate, Oz CLI, web app, API [W1]
|
not in the docs I read (Oct 2026) | No. Everything runs on your machine [H1] |
- C1 Cursor models · C2 Cursor 3.0 changelog · C3 Cursor worktrees · C4 Cursor cloud agents · C5 Cursor changelog
- W1 Warp: run multiple AI coding agents · W2 Warp changelog 2026 · W3 Warp Universal Agent Support
- Z1 Zed external agents · Z2 Zed Terminal Threads · Z3 Zed Parallel Agents
- H1 Hermes IDE README · H2 Hermes IDE release notes
The first row splits the four into two camps. In the docs I read,
Cursor runs its own agent and lets you pick the model. Warp, Zed
and Hermes also run other vendors' agents. Within that second
camp, look at the "how it shows up" row. When an agent runs in a
real terminal, a slash command its vendor shipped this morning
works this morning. Warp's tabs and Zed's Terminal Threads get you
that, and Hermes runs every agent that way.
Who needs you, review, and landing
| Cursor | Warp | Zed | Hermes IDE | |
|---|---|---|---|---|
| "An agent needs you" signal | Unread badges on agents, with Dock and menu-bar counts on macOS; a status dot when a cloud subagent waits on you; phone push when a cloud agent asks a question or needs approval [C7] [C8]; CLI desktop notifications when a turn ends or the agent is blocked [C9] | Attention indicator on tabs; in-app and system notifications (the guide lists Claude Code, Codex, OpenCode; the April launch post says any CLI agent) [W1] [W3] | Desktop notification and optional sound when the agent finishes or waits [Z5]; Terminal Threads notify when a process needs your attention [Z2] | Status per agent (working, needs approval, asked you, done, error, idle); title-bar badge; inbox oldest first with peek; ⌘I jumps to the longest wait; notifications only when blocked or done [H1] [H2] |
| Review | Live diff view while the agent works; Review → Find Issues after a task; Agent Review against main from Source Control [C10] [C11]; restore any checkpoint [C12]; /best-of-n compares candidates [C3]
|
Code Review panel: diffs against uncommitted work or main, revert single hunks, inline comments agents act on [W5], including running third-party agents [W3] | Review Changes puts every agent edit in one tab; accept or reject each hunk, or all of them; Restore Checkpoint on each message [Z5] | Every turn saved in git, with Diff, Restore and Undo; Review Desk by turn or file, risk flags, line comments sent to the agent that wrote the lines, revert one turn [H1] [H2] |
| Landing the work | Diffs view to review, commit and manage PRs [C13]; /apply-worktree into the main checkout [C3]; cloud agents return merge-ready PRs [C4]
|
PR info shown in tabs [W3]; compare your branch with main in Code Review [W5]; a commit or merge step not in the docs I read (Oct 2026) | Git panel: stage hunks, commit with an AI-drafted message, push and pull, resolve conflicts [Z6]; a PR step not in the docs I read (Oct 2026) | Land sheet: commit, open a PR or merge locally, drafted message, undo; your checks run after each turn and before landing, and a failing check brings a warning with "Land anyway" [H1] [H2] |
- C7 Cursor release notes · C8 Cursor mobile · C9 Cursor CLI changelog · C10 Cursor: review agent changes · C11 Cursor Agent Review · C12 Cursor agent overview · C13 Cursor Agents Window
- W5 Warp Code Review panel · Z5 Zed agent panel · Z6 Zed Git · other sources as listed under the first table
Money, platforms, license
| Cursor | Warp | Zed | Hermes IDE | |
|---|---|---|---|---|
| Bring your own subscription | Your own OpenAI, Anthropic, Google, Azure or Bedrock API key, billed by the provider; chat models only [C14] | Free plan: "Bring your own AI inference"; sign in with ChatGPT since 2026-09-23 [W4] [W2] | Yes: external agents bill through your own provider relationship [Z1] | Yes: every agent uses its own CLI sign-in; several accounts per agent [H1] |
| Platforms | macOS, Windows, Linux (.deb, RPM, AppImage) [C15]; iOS app [C8] | macOS, Linux, Windows [W3] | macOS, Windows, Linux [Z3] | macOS (Apple Silicon, Intel), Windows, Linux (.deb, AppImage) [H1] |
| Price as listed | Hobby free; Individual from $20/mo; Teams $40/user/mo [C6] | Free; Build $20/mo; Max $200/mo; Business $50/user/mo; lower with annual billing [W4] | Personal free; Pro $10/mo; Business $30/seat/mo [Z4] | Free (agents billed by their own vendors) [H1] |
| License | Proprietary; the terms bar reverse engineering [C16] | Client open source under AGPL v3 [W6] | Open source [Z3] | Source-available (BSL 1.1); each release becomes Apache 2.0 after three years [H1] |
- C6 Cursor pricing · C14 Cursor: bring your own API key · C15 Cursor download · C16 Cursor terms of service
- W4 Warp pricing · W6 Warp on GitHub · Z4 Zed pricing
How you find out an agent is waiting
With more than two agents running, this is the row I'd read first.
Every tool here tells you something now. Cursor badges unread
agents and pushes a cloud agent's questions to your phone. Warp and
Zed notify you when a CLI agent needs input, and Zed's agent panel
can play a sound when it's done.
Hermes treats "who needs me" as a queue. Every session gets a
status with no setup. The ones blocked on you land in an inbox,
oldest first, with a peek at what each one asked.
Real Hermes window, test build with stand-in agents: three agents waiting on approval, oldest first, with a peek at the selected one.
⌘I (Ctrl+Shift+I on Windows and Linux) jumps to the agent that has
waited longest. Notifications fire only when an agent is blocked or
done, never for the session you are looking at. If you step away,
Hermes can post to a web address such as ntfy or Telegram. The
message carries the agent, the task, its state, the repo folder
name and the session number, never prompts or code. Hermes never
answers a permission prompt for you.
How you review, and how the work lands
Here the other three have real tools, and they deserve the credit.
Zed's Review Changes button puts every edit an agent made into one
tab, where you accept or reject each hunk
(agent panel). Warp's Code
Review panel reverts single hunks and takes inline comments that
agents act on, and Universal Agent Support sends those comments to
a running third-party agent
(Code Review,
Warp blog).
Cursor shows a live diff while the agent works, runs Agent Review
to find issues after a task, and its /best-of-n runs several
candidates in their own worktrees so you can compare approaches
(review,
worktrees).
Hermes changes the unit of review. Every agent turn is saved in
git, including changes made by shell commands, without touching
your branch, staging area or stash. So the Review Desk (⌘G, or
Ctrl+Shift+G on Windows and Linux) can show changes by turn as well
as by file. You can usually revert one bad turn without losing the
good ones after it, and a line comment goes back to the agent that
wrote the lines.
Real Hermes window, test build with stand-in agents: the Review Desk flags an agent's edits to its own config and checks.
It also flags the edits you should never skim: lockfiles, CI
workflows, secrets, new binaries, and an agent editing its own
config or your checks. That last one is in the capture above. An
agent that "fixes" a failing test by changing what the check runs
is the kind of change that slips through a long diff.
Landing is one sheet. It commits, opens a PR or merges locally
into the branch the task started from. You get a drafted message
and an undo afterwards. Your own checks run at the end of each turn
and again before landing. If one fails, the sheet warns you and
offers "Land anyway". When the agent is Claude, Hermes sends it
back to fix a failing check, up to three times. An overlap badge
warns you when two sessions' recent turns touched the same files,
before you find out at merge time.
Cursor lands from its diffs view, where you review, commit and
manage PRs, or with /apply-worktree, and its cloud agents hand
back merge-ready PRs
(Agents Window,
cloud agents).
Where each one wins
Cursor wins if you want one vendor to handle all of it. Its
Agents Window runs agents locally, in worktrees, in the cloud and
over SSH from one place (3.0),
and recent entries add self-hosted machines, team pools and Remote
Control from iOS (changelog). It
has its own model, Composer (models),
plus Agent Review and best-of-N. Hermes has no cloud agents and no
model of its own.
Warp wins on reach. Its open-source terminal runs a long list
of CLI agents, notifies you, sends review comments to third-party
agents and lets you check in from your phone
(Universal Agent Support).
For teams it adds cloud orchestration with /orchestrate, so
agents run on cloud machines instead of your laptop
(guide).
Hermes runs everything on your machine, so it can't do that.
Zed wins if you want a fast native editor with agents inside
it. It's open source, ACP lets you mix agents per thread, Personal
is free with your own agent subscriptions
(pricing), and the agent panel reviews
edits hunk by hunk. Terminal Threads turns claude or codex into
a managed thread with notifications
(Terminal Threads), the
closest thing on this list to how Hermes works.
Hermes IDE wins after the agent starts, across vendors. You get
one status for every agent, an inbox for the blocked ones, and
review by turn with risk flags. On macOS and Linux, agents keep
running when Hermes quits, updates or crashes. It's free, and it's
new: Hermes 2.0 shipped on October 2, 2026, and 14 more releases
followed by October 11, so its track record is short. No cloud
agents, no Docker isolation.
Also worth knowing
Six more tools run parallel agents in worktrees. They stayed out of
the main tables to keep those readable, but one of them may fit you
better than any of the four.
| Tool | What stands out | Agents / models | Platforms | Price as listed |
|---|---|---|---|---|
| GitHub Copilot app | Worktree per session; Agent Merge watches CI and reviewers (GitHub blog) | Many vendors' models; Claude and Codex delegation on Pro+ and Max | macOS, Windows, Linux | Free; $10, $39, $100/mo (plans) |
| JetBrains Air | Local, Worktree or Docker per task; ACP agents | Codex, Claude Agent, Gemini CLI, Junie; your existing subscription or API key | macOS, Linux, Windows per help page | not in the docs I read (Oct 2026) |
| Claude Code desktop and agent view | Worktrees in .claude/worktrees/; "Needs input" state |
Claude models only | macOS, Windows, Linux (beta) (desktop) | Included in Claude plans from $20/mo (pricing) |
| Codex in the ChatGPT app | Hand off chats between Local and Worktree; notifications (app) | OpenAI models only | Desktop app on macOS, Windows, Linux (app) | Included in every ChatGPT plan, Free to Pro (pricing) |
| Devin Desktop (formerly Windsurf) | Agent Command Center, Merge button, hand-off to cloud Devin | Devin Local | not in the docs I read (Oct 2026) | Free; Pro $20/mo; Max $200/mo (billing) |
| Conductor | Polished worktree-per-task flow from setup to PR | Claude Code, Codex, Cursor, OpenCode; your own subscriptions | Mac (the only build its docs cover) | Free local tier; Pro $50/mo (pricing) |
Pick one
Match the tool to the setup you have today. A solo developer happy
with Cursor's model menu who wants cloud runs from a phone should
start with Cursor. A team whose agents already live in the terminal
and who wants them running in the cloud should try Warp. If you
open an editor before anything else and want agents inside it, try
Zed. If you run Claude Code next to Codex, or any two vendors'
agents on one repo, and the hard part is keeping track of them,
that is the setup Hermes IDE was built for.
If the Hermes line is you
I build Hermes IDE, so take my framing with that in mind and check
the tables against the linked docs. If that last setup is yours,
download it and try one thing:
press ⌘N (Ctrl+Shift+N on Windows and Linux), describe a task, open
+ options, and under Also on pick a second agent you're
already signed in to. Both open side by side, each on its own
branch, and you can review both by turn.
It's free, and the source is on GitHub. If it's useful, a
star on GitHub helps
other developers find it. If I got a row about Cursor, Warp or Zed
wrong, or Hermes is missing something you need, open an issue there.
If you missed the two earlier posts,
The Editor-First IDE Is Dead makes the case for the
console model, and
IntelliJ Was Built for You to Type Code covers what
that means for the classic IDE.
For the patterns behind running agents you can trust, the
AI Agents Pocket Guide is the short version.
Top comments (0)
Some comments may only be visible to logged-in visitors. Sign in to view all comments. Some comments have been hidden by the post's author - find out more