- 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
One of your agents stopped 20 minutes ago to ask for a yes on
npm install. It has been waiting ever since. Two more agents are
working somewhere else, on branches you haven't looked at yet.
Your IDE has no idea. It is showing you a file you didn't write. An
agent wrote it an hour ago.
That screen was designed for a world where you typed every line. The
typing has moved somewhere else, and the home screen hasn't followed.
The numbers moved first
The Stack Overflow Developer Survey 2026
says "Coding assistants and agents have pulled ahead as the dominant
use case for AI (66%)" and that "The overwhelming majority of
respondents now use coding assistants and agents daily (73%)". In the
2025 survey, 14.1% used AI
agents daily. The two surveys asked different questions, so treat the
jump from 14.1% to 73% as a trend with a wide margin.
Anthropic's Economic Index
from April 2025 points the same way. Across 500,000 coding
interactions, "79% of conversations on Claude Code were identified as
'automation'", against 49% on Claude.ai. When developers use an agent
tool, they lean much more toward letting it do the work.
The vendors moved too. In 2026 JetBrains, Cursor, GitHub and OpenAI
each shipped an app or a window built around running agents. The
dates are further down.
When agents write most of the diff, the main screen should show the
agents and what they need from you. A file is the wrong default.
Dead idea 1: the file tree and editor as the home screen
For about 25 years the IDE's home screen has been a file tree on the
left and an editor in the middle. The terminal, debugger and version
control dock around the edges. That layout assumes the scarce thing is
your attention on one file.
Now the scarce thing is your attention across several running agents.
The question you ask most is "who needs me?", and a file tree can't
answer it.
Hermes IDE, the tool I build, shows a list of sessions instead, each
with one status. Every agent gets a state with no setup: working,
needs approval, asked you, done, error or idle. When Hermes is
guessing the state rather than hearing it from the agent, the label is
dimmed, so you know how far to trust it.
From hermes-ide.com: a recreation of the 2.0 app with demo data.
Four vendors' agents in one sidebar, one status each.
Look at what sits in the middle of that window. It's an agent's
terminal, with its turns listed underneath, and no file is open.
Diffs and the git panel are still in the app when you go looking for
them.
The session list tells you what everyone is doing. The attention inbox
tells you who is blocked on you. A badge in the title bar counts the
agents waiting. The inbox lists them oldest first, with a peek at what
each one is asking. ⌘I (Ctrl+Shift+I on Windows and Linux) jumps
straight to the agent that has waited longest.
Real Hermes window, test build with stand-in agents. Three sessions
need approval, "1 of 3 waiting", with a peek at the selected one.
The inbox never answers for you. Hermes doesn't answer permission
prompts and never types into a terminal on its own. You press Enter,
land in the agent's pane, and answer it there.
Dead idea 2: one assistant in a sidebar
The first wave of AI IDEs gave you one chat panel docked to the side,
backed by whatever models the editor sold you. You picked an editor
and got its assistant.
That breaks the day you want Claude Code for one task and Codex for
another. It breaks again the afternoon one of them hits its usage
limit. Agent vendors now ship command-line agents with their own
commands, modes and sign-in, and they change them often.
Hermes runs each agent in a real terminal, showing the agent's
interface exactly as it would anywhere else. A vendor's new slash
command works in Hermes the day it ships, because Hermes doesn't
rebuild the vendor's UI. Today that covers Claude Code, Codex,
Antigravity CLI, Gemini CLI, GitHub Copilot CLI, OpenCode, goose,
Aider, Kiro CLI, Hermes Agent and any other command-line agent you
add. (Hermes IDE is not affiliated with Nous Research or its Hermes
Agent, which Hermes IDE can run.) Each agent uses its CLI sign-in, and
Hermes never asks for your tokens. You can add several accounts per
agent, and hand a task to another agent when one hits its limit.
Dead idea 3: one checkout
The editor-first IDE assumed one working copy. Put two agents in it
and they trample each other's files, and you can't review either one
cleanly.
Give every task its own git worktree. This isn't Hermes's idea and it
isn't news. By October 2026 the
GitHub Copilot app,
Cursor,
Claude Code desktop, Codex
in the ChatGPT desktop app,
JetBrains Air,
Zed,
Warp,
Conductor
and Devin Desktop (formerly
Windsurf) all offer it.
Underneath, it's plain git. You can try it in any repo:
$ cd /home/dev/acme-api
$ git worktree add -b hermes/fix-login ../fix-login
Preparing worktree (new branch 'hermes/fix-login')
HEAD is now at bd6270e init
$ git worktree add -b hermes/add-pagination ../add-pagination
Preparing worktree (new branch 'hermes/add-pagination')
HEAD is now at bd6270e init
$ git worktree list
/home/dev/acme-api bd6270e [main]
/home/dev/add-pagination bd6270e [hermes/add-pagination]
/home/dev/fix-login bd6270e [hermes/fix-login]
Each branch gets its own folder, and all of them share one repository.
Your main checkout stays where you left it.
You could stop here with tmux and a few scripts, and some people do.
The scripts won't tell you which agent is blocked, and they won't keep
a turn-by-turn history you can review and restore.
In Hermes, ⌘N (Ctrl+Shift+N on Windows and Linux) opens the task
launcher. You describe the task and press Enter. The agent starts in
a terminal on a new branch (hermes/<task>) in a fresh worktree, with
your description as its first prompt. When the new task's
dependencies match the main checkout they're ready in seconds, and
parallel dev servers get separate ports. A .hermes/worktree.toml
file holds setup commands and the files to copy over, like .env.
And when two sessions' recent turns touched the same files, an overlap
badge warns you before landing becomes a merge fight.
Dead idea 4: autocomplete as the headline AI feature
For a few years "AI in the IDE" meant gray ghost text finishing your
line. That was a typing feature. It saved keystrokes.
When an agent writes 300 lines in one turn, writing stops being the
expensive step. Deciding what to keep is the expensive step now, so
review and landing become the headline features.
Hermes saves every agent turn in git, including changes made by shell
commands, without touching your branch, your staging area or your
stash. A bar under the terminal gives each turn a Diff and a Restore,
and Restore comes with Undo.
The Review Desk (⌘G, or Ctrl+Shift+G on Windows and Linux) shows
changes by turn or by file. It flags the edits you'd want to see
first: lockfiles, CI workflows, edits that look like secrets, new
binaries, and an agent editing its own config. A line comment goes
back to the agent that wrote that line. You can revert one turn and
keep the rest.
Real Hermes window, test build with stand-in agents. The Review Desk
flags an agent editing its own config ("agent config") and the checks
file ("checks changed").
Land commits, opens a PR or merges locally in one step. It writes the
commit message for you and lands into the branch the task started
from. If you change your mind, undo it.
Your checks, any commands you choose, run at the end of each turn and
again before landing. When a check fails, Claude is sent back through
its stop hook to fix it, up to three times. With other agents, you
click "Send failures back". If checks still fail when you land, Hermes
warns you and offers "Land anyway", so the call stays yours.
That's also the answer to "agents write bad code". Sometimes they do.
A control tower is the place where you refuse a landing.
What the big vendors shipped in 2026
The strongest evidence that the old layout is finished is what the
companies selling IDEs and agents shipped this year:
- March: JetBrains launched Air in public preview, "an agentic development environment for delegating coding tasks to multiple AI agents and running them concurrently". In JetBrains' words, Air builds "tools around the agent" instead of adding tools to an editor.
- April: Cursor 3.0 added the Agents Window, to "run many agents in parallel across repos and environments".
- June: Windsurf became Devin Desktop, and the GitHub Copilot app went GA with "parallel sessions across repositories, each on its own branch and worktree".
- July: "Codex is now part of the ChatGPT desktop app on macOS and Windows" (changelog).
- September: Devin Desktop's changelog: "Cascade has been removed. Devin Local is now the only agent available in Devin Desktop."
None of them deleted the editor. Cursor says "You can switch back to
the IDE anytime, or have both open simultaneously". JetBrains says
"Air handles the agent-powered development; your IDE handles the
rest." The editor survives as a tool you open when you need it. It
lost the home screen.
What changes when you mix vendors
If you use one vendor's agent all day, its own window may be all you
need. Claude Code desktop and the ChatGPT app are tuned to their
vendors' models, and they're good at it.
Hermes is for the other case: you run agents from several vendors and
want each in its real interface, with one inbox and one place to
review and land. Other tools are close to this, and you should look
at them.
Warp
runs Claude Code, Codex and other CLI agents in tabs, with
notifications and inline review comments.
Zed's Terminal Threads turn
claude or codex into managed threads in its sidebar.
JetBrains Air
runs several agents with worktree or Docker isolation. If one of them
fits how you work, use it.
What Hermes doesn't do yet: there are no cloud agents and no Docker
isolation. Agents run on your machine, or on a host you SSH into, and
each one still talks to its vendor's service the way it does anywhere
else.
The control tower checklist
Whatever you pick, hold it to seven jobs:
- Start. A task description becomes a running agent in one step.
- Run any agent. Each vendor's CLI in its real interface, with its sign-in.
- Isolate. Every task gets its own branch and worktree.
- Tell you who's blocked. One status per agent, and an inbox with the longest wait at the top.
- Review per turn. See each turn, comment on its lines, revert it alone.
- Land with undo. Commit, PR or merge after your checks run, and reverse it if you need to.
- Survive a crash. Agents keep running if the app quits, updates or crashes, and you reattach where you were.
Run your current setup against that list. Hermes is one concrete
example. It does all seven on macOS and Linux, and the first six on
Windows. The list is the bar I build it against.
Try it on one real task
I build Hermes IDE. It's free, source-available under BSL 1.1, and
runs on macOS, Windows and Linux.
Download it, open a repo you're
working in, press ⌘N (Ctrl+Shift+N on Windows and Linux), describe a
real task and press Enter. Start a second one with a different agent.
When the badge in the title bar lights up, press ⌘I (Ctrl+Shift+I).
If the control tower idea makes sense to you,
star the repo on GitHub.
It's built in the open: Hermes 2.0 shipped on October 2, 2026, and 14
more releases followed by October 11. A star is how other developers
who mix agents find it. If something breaks or your agent is missing,
open an issue.
If you build agents as well as run them, the
AI Agents Pocket Guide covers
the patterns behind them.
Top comments (0)