How to Set Up Hermes as an AI Supervisor for OpenClaw

Running an AI agent is one thing. Knowing whether it is producing clean, fresh, non-repetitive output at 3 a.m. is another. Hermes is an open-source supervisor agent from Nous Research that watches your OpenClaw instance through Discord, verifies output quality, and only pings you when something actually needs human judgment. This guide walks you through the full setup, from install to a verified three-message supervision loop.

What Is Hermes and Why Does AI-to-AI Supervision Matter?

If you are running OpenClaw as your AI agent platform, you already have agents generating content, processing data, or executing workflows around the clock. The problem is oversight. A human cannot monitor every output from every agent in real time. But you also cannot let agents run completely unsupervised without risking stale data, quality drift, or repetitive outputs slipping through.

Hermes solves this by acting as a dedicated supervisor agent. It does not generate content. It does not trade. It does not publish. It verifies and routes. Think of it as a quality control layer that sits between your production agents and you, the human operator. It checks that outputs are fresh, well-scored, and non-repetitive, then either acknowledges clean outputs or escalates problems that require your judgment.

The communication happens through a private Discord channel using a structured intent marker protocol. Every message between Hermes and OpenClaw must contain exactly one intent marker and one @mention. The protocol enforces a maximum conversation depth of three messages, with [ACK] as a terminal marker that stops the exchange. This prevents the infinite ping-pong problem that plagues naive multi-agent setups.

What You Will Need Before Starting

• An OpenClaw instance running on a Linux server (Ubuntu VPS recommended)
• A Discord server where you have admin permissions
• An Anthropic API key (or OpenRouter API key if you prefer routing through OpenRouter)
• SSH access to your OpenClaw server
• Discord Developer Mode enabled (User Settings, Advanced, Developer Mode ON)

Step 1: Install Hermes on Your Server

SSH into the same Linux server where OpenClaw is running. Hermes installs with a single command:

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash
source ~/.bashrc
hermes   # verify it launches

The installer creates two files you will edit throughout this guide:

• ~/.hermes/config.yaml — model selection, identity, and behavior settings
• ~/.hermes/.env — API keys and Discord wiring

Since your OpenClaw instance is likely already on Anthropic (Claude Sonnet or Opus), the simplest billing setup is to wire Hermes to Anthropic as well. If you want Hermes on a cheaper model, OpenRouter lets you route to Haiku without a separate Anthropic key:

# Option A: Anthropic directly
ANTHROPIC_API_KEY=your-key-here

# Option B: OpenRouter for cheaper supervisor model
OPENROUTER_API_KEY=your-key-here

Step 2: Create the Discord Coordination Channel

The key architectural decision here is that Hermes and OpenClaw communicate through a dedicated private channel, not through your existing channels. This keeps supervision traffic separate from production output.

1. Open your Discord server. Go to Edit Server, then Channels, then click + Add Channel.
2. Name it #operator-ai and set it to Private.
3. Give both your OpenClaw bot and the new Hermes bot Read and Write access.
4. Right-click #operator-ai, select Copy Channel ID, and save it. You will use this ID three times in the configuration below.
5. Create a second channel called #hermes for Hermes' default home. Copy that channel ID too.

Step 3: Create the Hermes Discord Bot

1. Go to the Discord Developer Portal. Click New Application and name it Hermes.
2. In the left sidebar, click Bot, then Add Bot.
3. Under Privileged Gateway Intents, enable MESSAGE CONTENT INTENT. This is required for Hermes to read messages in the coordination channel.
4. Copy the Bot Token and save it securely.
5. In the left sidebar, go to OAuth2, then URL Generator. Under Scopes, select bot. Under Bot Permissions, select Send Messages and Read Message History.
6. Copy the generated URL, open it in your browser, and invite Hermes to your server.

Step 4: Wire Hermes to Discord

Edit ~/.hermes/.env with all the IDs you collected in the previous steps:

# Anthropic (or swap for OpenRouter)
ANTHROPIC_API_KEY=your-anthropic-key

# Discord wiring
DISCORD_BOT_TOKEN=<hermes-bot-token>
DISCORD_HOME_CHANNEL=<your-hermes-channel-id>
DISCORD_ALLOW_BOT_CHANNELS=<your-operator-ai-channel-id>
DISCORD_INTER_AGENT_CHANNEL_ID=<your-operator-ai-channel-id>
DISCORD_INTER_AGENT_PEER_MENTION=<@YOUR_OPENCLAW_BOT_ID>

To find OpenClaw's bot ID: with Developer Mode on in Discord, right-click OpenClaw's bot and select Copy User ID. Format it as <@THAT_ID>, for example <@14782827497553920>.

Step 5: Give Hermes Its Supervisor Identity

This is where you define what Hermes does and does not do. Edit ~/.hermes/config.yaml:

agent:
  model: claude-3-5-haiku-20241022  # or sonnet for more reasoning
  system_prompt: |
    You are an operator supervisor for an OpenClaw instance running in Discord.
    Your job:
    - Monitor OpenClaw's output channels for quality issues
    - Verify that outputs are fresh, well-scored, and non-repetitive
    - Escalate to the human operator only when something requires judgment
    - Acknowledge clean outputs so the loop closes

    You do not generate content. You do not trade. You do not publish.
    You verify and route.

    When communicating with OpenClaw in #operator-ai, you must:
    - Always @mention OpenClaw's bot using its mention token
    - Always include exactly one intent marker per message:
      [STATUS_REQUEST], [REVIEW_REQUEST], [ESCALATION_NOTICE], or [ACK]
    - Never reply to [ACK] messages -- ACK is terminal
    - Keep replies to one message unless the other agent explicitly follows up
    - Max conversation depth: 3 messages

The critical lines are the intent marker rules and the explicit prohibitions. Without these constraints, Hermes could drift into generating content or getting stuck in conversational loops with OpenClaw.

Step 6: Wire OpenClaw's Ops Agent

Two files need changes on the OpenClaw side. First, add the channel binding in ~/.openclaw/openclaw.json:

{
  "agentId": "ops",
  "match": {
    "channel": "discord",
    "peer": {
      "kind": "channel",
      "id": "<your-operator-ai-channel-id>"
    }
  }
}

Second, append the Hermes protocol rules to your ops agent's SOUL.md file (usually at ~/.openclaw/agents/ops/SOUL.md):

## Hermes Protocol

Hermes is an allowed oversight peer operating in #operator-ai. Rules:
- Respond ONLY in #operator-ai, ONLY when @mentioned by Hermes
- Every message must contain exactly one intent marker:
  [STATUS_REQUEST] | [REVIEW_REQUEST] | [ESCALATION_NOTICE] | [ACK]
- [ACK] is terminal -- do NOT reply to it
- No request intent in an incoming message -> do NOT reply
- One message per turn -- no chains
- Always use the real Discord mention token <@HERMES_BOT_ID>, never bare text
- Max depth: 3 messages before the loop must close

Replace HERMES_BOT_ID with Hermes' actual Discord user ID (right-click Hermes in Discord, Copy User ID).

Step 7: Start Hermes

The simplest way to start is the CLI command:

hermes --discord

For production use, run Hermes as a systemd service so it survives SSH disconnects and restarts automatically on failure:

sudo tee /etc/systemd/system/hermes.service << EOF
[Unit]
Description=Hermes Supervisor Agent
After=network.target

[Service]
User=root
WorkingDirectory=/root/.hermes
ExecStart=/usr/local/bin/hermes --discord
Restart=always
RestartSec=10
EnvironmentFile=/root/.hermes/.env

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl enable hermes
sudo systemctl start hermes
sudo systemctl status hermes

Step 8: Test the Intent Marker Protocol

Trigger a manual status check by posting in #hermes or DMing the Hermes bot:

Check OpenClaw's ops agent status in #operator-ai

You should see this three-message sequence appear in #operator-ai:

Three messages, three markers, clean termination on [ACK]. If you see messages continuing past the [ACK], check that both config.yaml (Hermes side) and SOUL.md (OpenClaw side) include the [ACK] termination rule.

How Does the Intent Marker Protocol Work?

Every message between the two agents must follow three rules: one intent marker, one @mention, one message per turn. Here is the complete reference:

The enforced rules: no marker means the message is ignored. No @mention means the message is ignored. [ACK] is always terminal. Maximum three turns per exchange. These constraints prevent the runaway conversation loops that make most multi-agent systems unreliable.

Troubleshooting Common Issues

File Locations Reference

Frequently Asked Questions