All posts

Hermes Agent needs a home

Hermes Agent remembers, writes its own skills, and runs cron on a $5 VPS. Minion gives it shared memory, tasks and saved code that the next agent you open can use too.

8 min read
Sticker-style illustration: a winged sandal carrying an envelope flies along a dotted path toward a small indigo house, surrounded by chat bubbles, a key, a code tile and a clock tile.

Hermes Agent's own docs have a line I keep coming back to. It's in the memory guide , under "One agent per Hermes home": don't point two agent processes at the same home directory, and if they need shared memory, "use an external memory provider instead."

That's the argument I've been making for months, written by the people building one of the best agents out there.

Hermes is very good at being an agent. Nous Research shipped it in February under MIT. It runs wherever you put it: a $5 VPS, a GPU box, serverless that costs almost nothing while idle. One gateway puts it in Telegram, Discord, Slack, WhatsApp, Signal, email, SMS and iMessage, 20-plus surfaces in all. It has a learning loop that writes skills from experience and improves them as it uses them. It has cron. And last week's v0.21.5 swapped the Desktop MCP tab for a Connectors page, which tells you where Nous thinks the outside world plugs in.

That's the agent. It still isn't the home.

Hermes is the agent that grows with you. Minion is where what it grows into can live, so the next agent you open gets it too.

What Hermes already gets right

I wrote that OpenClaw 2 needs a home partly because a Claw on your laptop pauses when the lid closes. That argument doesn't transfer, and I'm not going to pretend it does. Put Hermes on a VPS and it doesn't sleep. Its cron fires on schedule, delivers to whatever chat you asked, and in no-agent mode runs a plain script with zero model calls. Its memory survives the session. Its skills pile up.

So this isn't "Hermes needs Minion to work." It works. The question is where its stuff lives, and who else can use it.

Where Hermes stops

Everything Hermes accumulates is scoped to one Hermes home, ~/.hermes/, on purpose:

  • Memory is two files in ~/.hermes/memories/. MEMORY.md is capped at 2,200 characters and USER.md at 1,375, and both are injected into the system prompt at session start. That's a good design for one agent's working notes. It is not a place for everything you and every agent you use need to know.
  • Skills live in ~/.hermes/skills/. Cursor, Claude Code and Codex don't read them.
  • Keys live in ~/.hermes/.env and are exported into the process environment so plugins and skills can use them. The agent's process holds the raw values.
  • Cron jobs live in ~/.hermes/cron/jobs.json, inside that one install.

None of that is a flaw. It's an agent keeping its own house. But the morning you open Claude Code for a coding session, none of it comes along. The thing Hermes learned about your deploy process, the GitHub token it uses, the job that watches your inbox: all of it stays on the VPS.

Your assistant accumulates things worth keeping , and those things shouldn't live inside any one agent. Hermes' docs say the same about memory. I'd say it about the rest too.

What Minion keeps

Minion isn't a Hermes memory plugin and it isn't a second chat agent. It's an MCP server with two tools, search and execute. Hermes does the reasoning. Minion makes zero inference calls . When Hermes executes code, that code runs in Minion's Node.js sandbox with access to the shared state it needs:

  • Secrets resolve inside Minion's fetch gateway. They never enter Hermes' prompt or its environment.
  • Saved packages keep real version history. A one-off that works becomes code you own, and any connected agent can import it.
  • Scheduled jobs run package exports on Minion's server, with no model on the run.
  • Memories live in your account, and any agent you connect can search them.
  • Tasks keep the next actions in a shared team list, with notes, tags, priorities, due dates and completion. Hermes can add them; another connected agent or a person in the dashboard can pick them up.
  • An inbox lets services reach your assistant without going through one chat app.

The code isn't how Minion talks. The code is what Minion keeps.

The next step travels too

Sometimes the useful thing an agent produces is a task. You're talking to Hermes in Telegram and say, "Add a task to review the launch on Friday. High priority, tag it launch, and note that we need to check the release notes."

Hermes saves it in Minion. The next morning, you ask Claude Code for the team's open launch tasks, and the same action is there with its notes and due date. When the review is finished, you can ask either agent to mark it complete or check it off in the dashboard. Completed work stays in the list.

It's a small feature with a useful consequence: the next step survives the conversation. You can filter open or overdue work, change priorities, and reopen a task without reconstructing what another agent said. The Tasks guide covers the dashboard and agent calls.

They stack. They don't compete.

Same move I made with gateways , with Executor , and with OpenClaw. Different layer, same stack.

Hermes is the front door that's always open: the gateway, the chat apps, the learning loop, the model you picked. Minion is the factory behind it: the secrets, the packages, the jobs, the memories and tasks every other MCP host can ask for.

Hermes keeps its own MEMORY.md for its working notes. Minion holds the shared stuff. A useful thing Hermes figures out in Telegram at 11pm becomes a package the coding agent you open at 9am can run.

There's no conflict in using both. There's a conflict in pretending either one is the whole stack.

Connect Hermes to Minion

Minion's MCP URL is https://app.minion.codes/mcp. Hermes speaks Streamable HTTP and MCP OAuth 2.1, which is exactly what that URL expects.

If Hermes isn't in the Get started chooser, pick Not listed. That gives you the MCP URL, which is all Hermes needs.

Add Minion to ~/.hermes/config.yaml: 

mcp_servers:
  minion:
    url: "https://app.minion.codes/mcp"
    auth: oauth

Then, from a fresh terminal: 

hermes mcp login minion
hermes mcp test minion

login opens the Minion authorize window. Sign in if needed, approve access, and you're done. Run it from a fresh terminal, not from inside a running session: Hermes auto-reloads MCP when its config changes, but that reload gives up after 30 seconds, which isn't enough time to finish OAuth. test is the part that proves the server actually answers. Start a new session or run /reload-mcp and the Minion tools show up.

In Hermes Desktop, Authorize on the Minion server does the same login. If Hermes lives on a remote box, hermes mcp login prints the authorize URL and lets you paste the redirect back in; Hermes' OAuth over SSH guide has the details. Their MCP docs cover the rest of the config shape.

Your Minion account email must be verified before authorize can finish. If the window asks you to verify, keep it open, finish verification, then continue.

Once the connection works, ask Hermes to search Minion before it executes anything. Get started Step 2 gives you one prompt that has Hermes offer a few concrete first wins, then make one of them in your account, often a package you own . That's the moment something Hermes learned stops being a note in one home and becomes something every agent can use.

What this looks like on day one

A few things that get better the afternoon you connect them:

  • The morning cron job that hits an API with a key from .env becomes a Minion package. The key becomes a Minion secret Hermes can use and never read. Hermes' cron can keep the schedule and call the export, or a Minion job can take it over while Hermes stays the voice in Telegram.
  • A skill Hermes wrote that turned out to be mostly code gets saved as a package. Now Cursor can run it too.
  • The preferences that matter to every agent go into Minion memory. USER.md stops fighting for its 1,375 characters.
  • A next action from a Telegram conversation becomes a tagged Minion task. You can ask another agent for the team's open tasks or finish it in the dashboard.
  • You open Claude Code the next morning, point it at the same home, and it already knows the job exists.

I wrote this on October 1, 2026, a week after Hermes v0.21.5 landed. Hermes ships fast, and so does Minion. The layering is the part I don't expect to age out: an agent that grows wherever you put it, and a home that every agent shares.

Your move

If you already run Hermes, add Minion today: app.minion.codes/app/onboarding .

If you don't have either yet, start with whichever pain you actually have. Hermes Agent is at hermes-agent.nousresearch.com . Create a free Minion account at app.minion.codes/signup .

Either way, look at what's piling up in ~/.hermes/ that you'd want the next agent to have. Once you see it, you'll want a place for it that isn't one agent's home directory.

Continue reading