---
title: How to Become a Hermes Agent Operator
summary: >-
  Go from a single Hermes install to a control room orchestrating a team of
  specialist agents on one cheap VPS. Covers install, memory and SOUL.md, the
  orchestrator pattern, messaging surfaces, cron, and the operator mindset that
  makes it all compound.
author: Mike
authorUrl: 'https://x.com/mikenevermiss'
category: Orchestration
difficulty: Intermediate
readingTime: 5
date: '2026-06-17'
tags:
  - operator
  - control-room
  - multi-agent
  - delegation
  - marketing
  - vps
integrations:
  - Hermes Agent
  - Telegram
  - Discord
  - Slack
  - VPS
agents:
  - name: Control Room
    role: >-
      An orchestrator profile that holds no specialist knowledge — its only job
      is to break down incoming jobs, route subtasks to the right specialist via
      delegate_task, and assemble the results.
  - name: Researcher
    role: >-
      A specialist profile that monitors competitors and trends, with its own
      SOUL.md, memory, and skill library focused on a single domain.
  - name: Writer
    role: >-
      A specialist profile trained on your brand voice from example content,
      automatically writing a skill file from the samples you feed it.
  - name: Scheduler
    role: >-
      A specialist profile that manages a content queue and posts drafts on a
      schedule.
---

## What This Flow Covers

This is an operator's path: how to grow from a single Hermes install into a control room that coordinates a team of specialist agents — the functional output of a small content team running 24/7 on a $6 VPS.

Hermes is an open-source autonomous agent by Nous Research. It runs on a laptop or a cheap VPS, remembers everything across sessions in SQLite, and writes its own reusable skills as it works. You control it through a terminal, Telegram, Discord, Slack, or email — whichever surface fits your workflow.

The core promise is compounding. On day one Hermes is a capable assistant. By day thirty it has built a library of skills from your exact use cases, and repeating the same work gets faster and tighter every time.

## Install Hermes in Two Minutes

Run one `curl` command from the official Nous Research repo to install Hermes. The installer pulls Node.js, Python dependencies, SQLite, and the Hermes runtime automatically. The whole process takes under three minutes on a decent connection.

Once installed, a setup wizard runs and asks which model provider you want. The three most common choices:

- **Anthropic** (`claude-sonnet-4`) — high quality
- **OpenAI** (`gpt-5.4` with thinking mode) — a popular daily driver
- **OpenRouter** (`qwen/qwen-3.5`) — free and capable for routine work

After setup, run `hermes` to open the CLI. Give it a simple job first — something like "summarize my last five GitHub notifications." If it responds with real output, your install is working. Everything from here builds on that foundation.

## Understand What You Just Installed

Hermes stores everything inside `~/.hermes/`. Skills it builds live in `~/.hermes/skills/`. Session history is in SQLite with full-text search, meaning it can retrieve something you told it three weeks ago even if it is not currently in active memory.

Memory works in three layers:

- **Short-term** — the current session
- **Working memory** — important task context
- **Long-term** — through `MEMORY.md` and `USER.md` files

The agent reads these files at the start of every session to rebuild context.

The agent's identity lives in `SOUL.md`. This file is the equivalent of a system prompt written as a charter. It defines what the agent prioritizes, how it communicates, and what it avoids. Write it before you start assigning real work.

## Set Up Your Agent Control Room

A control room is one Hermes profile configured to orchestrate everything else. Create it with:

```bash
hermes profile create control-room
```

This profile holds no specialist knowledge — its only job is routing tasks to the right sub-agent and tracking results.

Each specialist agent is its own profile with its own `SOUL.md`, its own memory files, and its own skill library. Create a researcher profile, a writer profile, a scheduler profile. Each one stays focused on a single domain and gets better at it over time.

Wire everything together by enabling the `delegate_task` tool on the control room profile. When you send the control room a job, it breaks it down and routes subtasks to whichever specialist is best suited. Results come back to the control room, which assembles and returns the final output.

## Connect Your Messaging Surface

The most useful thing you can do in the first week is connect Hermes to Telegram. Go to @BotFather, create a bot with a username ending in `_bot`, and paste the token into the Hermes gateway config. From that point, you can command your agents from your phone anywhere.

Since all sessions share the same SQLite database, you can start a job in the terminal and check its status on Telegram without losing any context. The conversation thread is one continuous record regardless of which surface you used.

For team setups, create a shared profile on the VPS and grant team members access via the messaging gateway allowlist. This gives your whole team one agent they can all query without you building any custom UI.

## Configure Scheduled Recurring Work

Hermes has a built-in cron system. Jobs are defined in `~/.hermes/cron/jobs.json` using natural-language frequency. The gateway checks every 60 seconds and runs due jobs in fresh, isolated sessions.

Useful starting jobs:

- A daily briefing pulled from your configured sources at 8am
- A weekly content draft generated from a topic queue
- A nightly summary of any repo activity

Each result delivers back to your Telegram or saves locally, whichever you set.

The key advantage of cron over manual prompting is that the agent builds skills from repeated job runs. After a few weeks of daily briefings, Hermes knows exactly how you like them formatted and stops asking clarifying questions.

## Grow From One Agent to a Marketing Operation

Once the control room and messaging are working, add specialist profiles for each marketing function: a research agent that monitors competitors and trends, a writer agent trained on your brand voice, a scheduler agent that manages and posts content drafts.

Teach each profile your style by feeding it examples early. Run `hermes profile create writer`, then in the first session paste five pieces of content you have already written and tell it "this is the voice and format you write in." It writes a skill file from those examples automatically.

With four profiles running on a $6 VPS — one orchestrator and three specialists — you have the functional output of a small content team running 24/7. Each agent compounds independently, and the control room coordinates the whole thing from a single command.

## What Breaks and How to Catch It

- **Skipping `SOUL.md`.** An agent without identity is technically capable but inconsistent — it will handle edge cases differently each time and drift from your expectations without you noticing.
- **Letting skills accumulate without review.** Hermes writes skills automatically, but not every skill it writes is correct. Run `hermes skills list` weekly and delete any that describe a flawed approach before the agent reinforces it further.
- **Long, degrading sessions.** If a session runs long and starts producing worse output, context is filling up. Use `/compress` inside the session to summarize older context, or start a fresh session and let Hermes pull what it needs from memory files. Don't let degraded sessions run indefinitely.

## The Operator Mindset

An operator's job is not to prompt. It is to define what the agents do, verify the output quality, and improve the skill library over time. The more precisely you define each profile's `SOUL.md` and the more consistently you assign the right work to the right profile, the better every agent gets.

Treat each profile as a hire. Give it a clear role, examples of the work you expect, and time to build up its skill library before you judge its output. The compounding is real, but it takes two to four weeks of consistent use to become obvious.

The agents do not replace judgment. They multiply the volume of work that your judgment can cover. Your job shifts from doing the work to reviewing it — and that is the leverage.

---

*This flow was shared by [Mike](https://x.com/mikenevermiss). Follow him for more AI articles. Hermes Agent is an open-source project by Nous Research.*
