- 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
Claude Pro, $20. ChatGPT Plus, $20. Cursor, $20. Three AI lines on
one card statement, $60 a month at list price, and on most days the
code that lands in your repo came out of Claude Code or Codex.
So which of those three lines is writing your code?
Two of them pay for model access. The third pays for an editor with
model access built in. For some developers that third line is money
well spent. Plenty of others could drop it tomorrow and not notice,
because it's a second meter on the same work.
What each subscription actually buys
Start with the agent plans. These are the list prices as of October
2026 (checked on October 12). Prices change, so check the linked
pages before you decide anything.
| Plan | Listed price | What it includes for coding |
|---|---|---|
| Claude Pro | $20/month ($17 billed annually) | Claude Code |
| Claude Max | from $100/month | Claude Code, with tiers at 5x or 20x Pro usage |
| ChatGPT Go | $8/month | Codex |
| ChatGPT Plus | $20/month | Codex |
| ChatGPT Pro | from $100/month | Codex (tiers at $100, $200 and $500) |
OpenAI's pricing page says all ChatGPT plans include Codex, the free
one included. Anthropic says Claude
Code "shares the same usage limits as the rest of your plan". On
Claude plans, your chats and your agent draw from one pool.
Now the editors and consoles, same date, same caveat:
| Product | Free tier | Paid tiers (as listed) |
|---|---|---|
| Cursor | Hobby, "Limited Agent requests" | Individual $20/month, Teams $40/user/month |
| GitHub Copilot | Free, "Limited chat and agent usage" | Pro $10, Pro+ $39, Max $100 a month |
| Warp | Free, "Bring your own AI inference" | Build $20/month ($18 annual), Max $200 |
| Devin Desktop (formerly Windsurf) | Free | Pro $20/month, Max $200/month |
| Zed | Personal, free with your own keys or external agents | Pro $10/month |
| Conductor | Free local workspaces on your Mac, your own subscriptions | Pro $50/month |
| JetBrains IDEs | ACP agents work without a JetBrains AI subscription | Optional JetBrains AI subscription |
| Hermes IDE | Free, source-available | — |
Read the paid column closely and much of it is model usage again.
Cursor's Individual plan lists "Access to frontier models" and "Cloud
agents". Warp's Build plan includes "$20 of agent usage included each
month at API rates". Stack Claude Pro, ChatGPT Plus and Cursor
Individual and you're buying model access three times, through three
meters that don't share a balance.
That isn't automatically waste. Cursor also ships Composer, its own
coding model. The question is
whether you use what's unique to the editor, or whether you mostly
use the editor as a window around Claude Code and Codex.
Ten agents burn quota ten times as fast
As of October 2026 nearly every tool runs several agents at once,
each in its own git worktree.
Cursor, the
GitHub Copilot app,
Claude Code desktop,
Codex in the ChatGPT desktop app,
Zed, Warp and others all do it. That changes what you run out of
first.
Anthropic puts it plainly in the
agent view docs:
"running ten agents in parallel uses quota roughly ten times as fast
as running one."
An editor subscription doesn't add a single token to your Claude
quota. When you work in parallel, two things help: seeing which
sessions eat the tokens, and moving a task to the other vendor you
already pay for when one hits its limit.
Real Hermes window, test build with stand-in agents. Token counts,
an estimated cost (≈$1.04) and a 91% context gauge, shown in the
session row, group header, Context panel and status bar.
The number is an estimate, priced at API list rates from the tokens
the agent reports, and it's labelled that way in the app. On a flat
plan, read it as a relative meter. Per session and per group, it
shows which task is eating your quota before the limit message
does.
The other free options
Hermes is not the only free way to run the agents you already pay
for, and you should know the others.
Zed's Personal plan is free with external
agents like Claude Agent and Codex CLI, and its
Terminal Threads turn
claude or codex into managed threads with notifications.
Conductor is free on the Mac
with your own subscriptions or keys. JetBrains IDEs connect
ACP agents
without a JetBrains AI subscription. Warp's free tier runs Claude
Code, Codex and other CLI agents in
tabs and panes,
and its own agent works with your own inference.
If one of those fits how you work, it's a fine answer to the title.
The full side-by-side is in my comparison post,
Hermes IDE vs Cursor vs Warp vs Zed: 4 Ways to Run Coding Agents in Parallel.
I built Hermes around the two things this post is about: several
accounts per agent, and handing a task to your other vendor when one
hits its limit.
What Hermes adds on top of the CLIs you pay for
I build Hermes IDE, so weigh this section with that in mind. It's
free and source-available under BSL 1.1 (each release converts to
Apache 2.0 after three years), on macOS, Windows and Linux. Hermes
2.0 shipped on October 2, 2026, and 14 more releases followed by
October 11.
Every agent runs its own interface in a real terminal. Claude Code
looks like Claude Code, Codex looks like Codex, and a vendor's new
commands work the day they ship. Agents use their own CLI sign-in.
Hermes never asks you for a token.
The part that keeps billing straight is accounts. Hermes lets you
keep several accounts per agent, each with its own models, and pick
one per task.
From hermes-ide.com: a recreation of the 2.0 app with demo data.
The ⌘N launcher (Ctrl+Shift+N on Windows and Linux) with every option
open. The first chip is agent plus account, "Claude Code · Work", and
the line at the bottom is the exact command Hermes will run.
That bottom line shows the mechanism. A Hermes account is a separate
config folder for that CLI. Claude Code reads its folder from
CLAUDE_CONFIG_DIR, and Codex reads its home from CODEX_HOME. You
can do the same thing by hand:
# Default Claude Code sign-in lives in ~/.claude
claude
# A second, separate sign-in, e.g. your work seat
CLAUDE_CONFIG_DIR=~/.claude-work claude
# Same idea for Codex
CODEX_HOME=~/.codex-work codex login
CODEX_HOME=~/.codex-work codex login status
Hermes keeps that bookkeeping for you. In Settings → Agents, "Add
account" creates the profile (an account named Work becomes
~/.claude-work) and opens a terminal for the CLI's own sign-in.
After that it's a chip in the launcher, and the launcher remembers
your usual agent and options per project.
The use case is boring: a work account and a personal one, or a team
seat next to your own Pro plan, kept apart so billing and data stay
where they belong. Follow each provider's terms and keep each account
to the work it belongs to. Don't use extra accounts to stretch a
limit.
When one agent hits its usage limit
This is where paying two vendors starts to pay off. You already have
ChatGPT Plus for Codex. When Claude Code runs out, that subscription
is spare capacity sitting right there.
Here is what happens in Hermes when Claude Code reports its limit.
The session shows "limited" with the reset time the agent reported,
and the attention inbox gets a limit item. "Hand off…" gives you two
choices, and then you pick Codex as the other agent:
| Choice | What happens |
|---|---|
| Continue in another agent (Codex here) | A Codex session starts in the same checkout and branch. Its first prompt carries the task (you can edit it) plus the list of files Claude changed. It sits under the original in the session list. |
| Duplicate to another agent (Codex here) | A Codex session starts on a child branch, <branch>--codex, in its own worktree, cut from the original branch. Uncommitted files from the original don't come along. |
Neither choice carries Claude's conversation history. With Continue,
Codex gets the task and the list of changed files, and starts its own
chat from there. Nothing hands off until you pick one, and Hermes
never answers a permission prompt for either agent.
When the $20 editor is still worth it
Some of what the paid editors sell has no free equivalent, and if
you use it daily, pay for it.
Cursor. Composer is Cursor's own model. Its
cloud agents run in isolated
VMs and can start from the desktop app, iOS, Slack, GitHub comments
or Linear, and come back as "merge-ready PRs". The iOS app now has
Remote Control for local agents
(changelog, October 6), and
/best-of-n runs several candidates in their own
worktrees. One
catch for the budget: cloud agents are "charged at API pricing for
the selected model" with a spend limit, on top of the plan.
GitHub Copilot. If your team lives in GitHub issues, the
issue-to-PR-to-CI loop is where Copilot is strongest, and the
Copilot app's
Agent Merge
watches CI and reviewers and can merge once conditions are met.
Pro+ and Max list delegating to Claude and Codex (in preview), so you
can run both under one Copilot bill. If one bill appeals more than
three, that's the product built for it.
Devin Desktop (formerly Windsurf). One subscription covers the
local editor, the CLI and the cloud agent, and a local session can
be handed off to cloud
Devin with its own VM.
And the plain gap on my side: Hermes doesn't offer cloud agents or
Docker isolation. If you need agents running on someone else's
machines, Hermes isn't that tool, and one of the products above is.
The decision table
| Keep paying for the AI editor if… | Use a free console on the CLIs you pay for if… |
|---|---|
| You use the editor's own model, like Cursor's Composer, every day | Most of your diffs come from Claude Code or Codex |
| You start agents from your phone, Slack or GitHub and want them in the cloud | Your agents run on your machine, in worktrees |
| You want Claude and Codex under one bill (Copilot Pro+ or Max, delegation in preview) | You already pay Anthropic and OpenAI directly, and want to move a task to the other when one hits its limit |
| Your team runs on GitHub issues and wants Agent Merge | You use more than one vendor and want each in its own interface |
| You need cloud VMs or containers | You keep work and personal accounts apart, per agent |
If most of your diffs come from the CLIs and you already pay two
vendors, the third line on that statement is the one to question.
If you want the bigger argument for why the agent belongs at the
centre of the screen, it's in
The Editor-First IDE Is Dead. Your Next IDE Is a Control Tower.
Try it with the accounts you already have
I build Hermes IDE, and the test I'd suggest is short.
Download it, open Settings →
Agents and add a second account for one agent you already pay for (a
work seat, say). Then press ⌘N (Ctrl+Shift+N on Windows and Linux),
describe a task and pick that account from the chip. The agent
starts in a real terminal on its own hermes/<task> branch, signed
in as that account.
No second seat? Start one task in Claude Code and one in Codex from
the same launcher. That's the pair the usage-limit handoff moves
work between.
If it earns a place in your setup,
star it on GitHub. It's
free and source-available, and a star helps other developers find
it. If something is missing or broken, or your agent isn't in the
list, open an issue.
If you're building agents yourself rather than just running them,
the AI Agents Pocket Guide
covers the patterns behind tools like these.
Top comments (0)