Hermes Agent: The Profile Is the Agent
Claude, Gemini and Codex all have two limits in common. You cannot easily keep them running around the clock, and each one talks only to its own vendor's models.
Hermes Agent from Nous Research is open source and removes both. Install it on your laptop, or put it on a VPS so it runs 24/7. Point it at whichever provider you want — Anthropic, OpenAI, Google, OpenRouter, or a model running locally on your own machine. Then talk to it from Telegram instead of from a terminal.
That is the pitch, and it is accurate. But it undersells the part that actually changes how you work:
One installation holds many profiles, and each profile is a separate agent — its own identity, its own memory, its own skills, its own boundaries.
You do not configure an assistant. You staff a small team, and then you send one message and watch them hand work to each other.
About this write-up
Written from the video on the channel; the walkthrough, the four profiles and the swarm run are what happened on screen.
Three things are labelled rather than asserted. The auto-captions garbled the product name and the URL badly, so both were checked against the official site before being printed here. The prices are the ones shown on the subscription screen on the day of recording, not figures verified against a pricing page. And the claim that a VPS install can still reach files on your laptop is stated in the video, not demonstrated on screen.
Prefer to watch it on YouTube?
Watch on YouTube — or subscribe to the channel for the next one.
Getting it installed
The site offers two routes: download it for your own machine, or deploy it to the cloud. For the desktop route there are two further choices — a one-line terminal installer that covers macOS, Linux and Windows, or a native desktop app for the same three. The walkthrough uses the macOS desktop app.
The installer runs an unattended sequence you can watch: system prerequisites, package downloads, key configuration, gateway configuration, desktop app build, finish. Budget around ten to fifteen minutes — that is the estimate given in the video, on his machine.
Then Launch Hermes, a short startup, and a chat window that looks like every other chat window. It will not answer yet. Nothing is wired to a model, and that is the next step.
The architecture, in one pass
Four layers, and the names matter later:
| Layer | What sits there |
|---|---|
| Entry points | The desktop app, the CLI, the messaging gateway, an MCP server |
| Hermes core | The agent loop, and the tools and files it can reach |
| Execution surface | A terminal, browser automation, code delegation, cron jobs, MCP connectors |
| State and knowledge | Profiles, memory, skills, plugins — and a database kept on your disk |
Requests arrive at an entry point, pass through the gateway, and reach the agent loop. The gateway is not optional: it is the layer that holds the message identity and session, and everything from Telegram to the desktop app goes through it.
The last row is the one the video calls the breakthrough, and the rest of this post is mostly about it.
Local or VPS: one difference that matters
Both run the same way through the same gateway. The difference is availability:
- Local — the agent exists while your machine is on. Close the lid, and nothing runs.
- VPS — it runs 24/7, which is what makes scheduled jobs and a chat bot worth having.
The video adds a stronger claim: that a VPS install can still reach down into files on your local machine, where an agent that runs on your laptop is confined to that laptop. If that holds, it removes the usual reason to keep an agent local. It is asserted rather than shown, so treat it as a claim to test rather than a fact to build on.
Models: bring your own, per role
Under Settings → Provider there are three ways to give the agent a brain:
- A local model — point Hermes at a model server running on your own machine. No usage cost.
- The Nous Portal subscription — on the screen in the video, a free tier at $0 and a paid tier at $20 a month. Through it you also reach models from the big providers.
- Your own provider keys — paste an API key from Anthropic, OpenAI, Google, OpenRouter and others, and use the account you already pay for.
Then Settings → Models splits the job four ways:
| Slot | What it is for |
|---|---|
| Main model | The default brain, with a reasoning level you set |
| Fallback model | What to use when the main one is unavailable |
| Auxiliary models | A model per task type — vision, MCP work — chosen independently of the main one |
| Mixture of agents | Several models answering together |
The auxiliary row is the interesting one. A task that needs careful tool-calling and a task that needs to read an image are not the same problem, and here they do not have to share a model.
Pick a main model, start a session, and the chat answers. Ask it the time, and you get it in UTC — a small thing, but the first evidence that the loop works end to end.
Telegram: the gateway in front of everything
Telegram is one adapter among several — WhatsApp, Slack and Discord appear in the same list. The path is the same for all of them: your message hits the gateway, which keeps the message ID and session, and forwards it down to the agent loop.
Setup offers two routes:
- Scan a QR code — the quick path, and the one used in the walkthrough.
- Create a bot by hand — register it with Telegram's bot manager, then paste the bot token and your own Telegram user ID into Hermes. Slower, and worth knowing because it is what the QR route automates.
One step is easy to miss: restart the gateway after saving. Configuration is read at gateway start, so until it restarts, your bot is talking to nothing.
After that, Telegram behaves like a normal chat. The typing indicator appears, the agent replies, and when it is told to answer in Vietnamese it both answers and records the preference. Asked for the weather in Hanoi, it goes to the web and comes back with a temperature and conditions.
Profiles: three files per agent
This is the centre of the tool. Each profile is a folder, and the folder holds three markdown files:
| File | Who writes it | What goes in |
|---|---|---|
user.md | you | Who you are: role, current work, goals |
SOUL.md | you | Who the agent is: identity, tone, working rules, boundaries, how to finish a task |
memory.md | the agent | Written over time, as the agent learns things worth keeping |
You seed the first two. The third is not something to fill in up front — it accumulates.
The walkthrough starts with a profile for its author: a SOUL.md covering identity, tone, working principles, what to do when producing content for the channel, where the limits are, and what finishing a task looks like. Then a user.md saying who he is, what he does now, and what he is aiming at. Hermes writes both to a folder on the local disk and loads them.
The payoff is immediate. Asked to draw up a three-month self-improvement plan, the answer is not generic advice — it is built around his channel, his exam and his certification, because those are in the files.
Four profiles, four jobs
One profile for yourself is not enough, which is the point. The video adds three more, each one a narrow worker:
| Profile | Job | Boundaries written into it |
|---|---|---|
| scout | Research: read, search, track AI tools, check findings against local notes | Read only. No file edits, no commands. Hands off to the others |
| writer | Produce the documents and the commands, in Vietnamese, with sources and dates | Writes; does not run things |
| ops | Run commands on the machine and record what each one returned | Does not fix the command, does not edit files, does not chase root causes |
Two things fall out of that table.
Narrow roles let you spend model money where it matters. A scout that only reads and searches can run on a cheap, fast model. The work that needs care gets the expensive one.
The boundaries are written, not enforced. "Read only, no commands" lives in the profile's SOUL.md as instructions to the model. Whether anything underneath refuses a command when the model tries one anyway is not shown in the video — and that is the question I would want answered before giving one of these profiles a key to anything important.
Checking the profiles is simple: ask each one who it is. Each answers with its own role, which is the cheapest confirmation that the files loaded.
The swarm: one message, four agents
With the profiles in place, one Telegram message sets all of them to work. The instruction, in substance:
Coordinate this. First, scout and ops in parallel: gather real data and summarise this week's topics. Then check all of it for accuracy, and drop anything vague or speculative. Finally, writer takes the clean data and writes the post, with sources, and sends it here.
Three stages — gather, verify, write — with the gate in the middle, so nothing reaches the writer until it has been checked.
What you watch is a task board. Tasks sit as to-do, ready or running, each one bound to the profile that owns it. Agents appear working in a terminal, searching the web, writing. As each task closes, the next one it was blocking starts: verification fires when research lands, and the write step fires when verification passes.
The run ends with a finished post, with sources, delivered back to the chat.
That is the shape worth stealing even if you never install this tool: parallel gatherers, a verification gate, then a single writer. The gate is what keeps the speculation out.
Artifacts, and where the output lands
Everything the agents produce — the posts, the research summaries — collects in an artifacts view, and on your own disk. Click any of them and you are looking at a local file.
That matters for an agent you let run unattended. If the output lives only in a chat window, you cannot diff it, version it, or check it later. Here it is just files.
Cron jobs: the agent starts the conversation
Scheduled jobs come with templates — a morning brief, a weekly review — and you can write your own. The job can be created in the app, or simply asked for in chat, which is what the video does:
Each morning, collect the AI news from the last 24 hours, write a short summary in Vietnamese, and send it to this chat.
Hermes creates the job from that sentence. Run manually, it comes back with a news digest in Telegram.
This is the half of "agent" that chat tools do not have: the agent starts the conversation. On a VPS, it keeps doing so while your laptop is shut.
Capabilities: skills, tools, connectors, plugins
The capability screen has four tabs:
- Skills — beyond the defaults, there is a Skill Hub with a searchable catalogue, grouped by category, each entry with its own documentation
- Tools — the same idea for tools
- Connectors — this is where MCP lives: Figma, GitHub and the rest
- Plugins — installed the same way
So the base install is a floor, not a ceiling, and the catalogue is the ceiling's current height.
What stands out
The profile is the unit of work. Not the chat, not the session. You decide what an agent is, what it knows about you, what it may touch, and which model it thinks with — and you decide that separately for each job you have.
The gateway makes the surface interchangeable. Desktop app, Telegram, CLI, MCP — all of them are entry points into the same loop with the same memory, so where you talk to it stops being an architectural decision.
Three files is a low price for a specialist. user.md, SOUL.md, and a memory.md that fills itself in. That is the whole configuration of an agent that behaves differently from the others.
Keep the boundaries honest. Written limits are only as good as the model's willingness to respect them. Before an agent with a terminal gets anything sensitive, find out what actually stops it — not what you asked it not to do.
Related
- OpenAI Codex: The Local Folder Is the Product — another agent that works on your real disk, and the permission model underneath it.
- Google Antigravity 2.0: The Settings Screen Is the Story — what a scheduled agent is allowed to touch, and who decides.
- Gemini 3.7 Flash: What Rank 23 Actually Buys You — dispatching several agents in parallel, and gating on the one that checks.