Hermes Agent Setup Guide: Get Started in Under 5 Minutes

1. What Is Hermes Agent?

Hermes Agent is an open-source AI agent framework built by Nous Research. It is currently at version 0.7.0 and has over 33,000 stars on GitHub.

What makes Hermes different from other agent frameworks:

• + Self-improving — learns from interactions and gets better over time without manual retraining
• + Multi-platform — one agent, six platforms (Telegram, Discord, Slack, WhatsApp, Signal, Email) plus CLI
• + Three-tier memory — short-term (conversation), medium-term (session), and long-term (persistent) memory built in
• + Lightweight — runs comfortably on a $5/month VPS with 1 GB RAM

If you are wondering how it compares to OpenClaw, we wrote a detailed Hermes Agent vs OpenClaw comparison. Short version: OpenClaw controls a full desktop via screen interaction, while Hermes works through chat platforms and APIs. Different tools for different jobs.

2. System Requirements

Hermes is lightweight. Here is what you need:

A $5/month VPS from any cloud provider (Hetzner, DigitalOcean, Vultr) handles Hermes easily. You do not need a GPU — the heavy AI work happens on the API provider side.

3. Installation

Two options: pip (simpler) or Docker (isolated). Pick whichever you are more comfortable with.

Option A: pip install

# Create a virtual environment (recommended)
python3 -m venv hermes-env
source hermes-env/bin/activate

# Install Hermes Agent
pip install hermes-agent

Option B: Docker

# Pull the official image
docker pull nousresearch/hermes-agent:0.7.0

# Run with a config directory mounted
docker run -d \
  --name hermes \
  -v $(pwd)/config:/app/config \
  -v $(pwd)/skills:/app/skills \
  nousresearch/hermes-agent:0.7.0

Docker is the better choice if you plan to run Hermes on a server long-term. It keeps everything contained and makes updates as simple as pulling a new image.

4. First Run

After installation, run the setup wizard:

hermes init

This creates a config.yaml file in your current directory. The wizard asks for:

1. Agent name — whatever you want to call your agent
2. LLM provider — OpenAI, Anthropic, or a custom endpoint
3. API key — your provider API key
4. Platforms — which channels to enable (you can add more later)

Once the config is generated, start the agent:

# Start the agent
hermes start

# Check that it's running
hermes status

You should see output like:

[hermes] Agent "my-agent" running
[hermes] Platforms: cli
[hermes] Memory: short-term ✓  medium-term ✓  long-term ✓
[hermes] Skills loaded: 0
[hermes] Listening...

With just CLI enabled, you can already chat with your agent in the terminal. Type a message and press Enter. Try something simple like Summarize the top 3 stories on Hacker News right now to verify everything works.

5. Connecting Telegram and Discord

The real power of Hermes is reaching your agent from anywhere. Here is how to connect the two most popular platforms.

Telegram

1. Open Telegram and message @BotFather
2. Send /newbot and follow the prompts to create a bot
3. Copy the bot token BotFather gives you
4. Add it to your config.yaml:

platforms:
  telegram:
    enabled: true
    token: "YOUR_TELEGRAM_BOT_TOKEN"

Discord

1. Go to the Discord Developer Portal and create a new application
2. Under Bot, click Add Bot and copy the token
3. Under OAuth2, generate an invite link with the bot and applications.commands scopes
4. Invite the bot to your server using the link
5. Add the token to config.yaml:

platforms:
  discord:
    enabled: true
    token: "YOUR_DISCORD_BOT_TOKEN"

After updating config.yaml, restart the agent:

hermes restart

The same process works for Slack, WhatsApp, Signal, and Email — each has a section in config.yaml with its own token or credentials field. The Hermes docs cover each platform in detail.

6. Basic Configuration

Your config.yaml controls everything. Here are the settings you will want to tweak first:

agent:
  name: "my-agent"
  model: "gpt-4o"           # or claude-sonnet-4-6, etc.
  temperature: 0.7          # lower = more focused, higher = more creative
  max_tokens: 4096          # max response length
  system_prompt: |
    You are a helpful assistant that specializes in...

memory:
  short_term: true          # conversation context
  medium_term: true         # session persistence
  long_term: true           # cross-session learning
  long_term_backend: sqlite # sqlite (local) or postgres

platforms:
  cli:
    enabled: true
  telegram:
    enabled: false
    token: ""
  discord:
    enabled: false
    token: ""

The three-tier memory system is what makes Hermes self-improving. Short-term memory tracks the current conversation. Medium-term persists across messages in a session. Long-term memory stores learnings in a database so your agent remembers things between restarts.

For most beginners, the defaults work great. The main thing to customize is the system_prompt — this is where you tell the agent what it should specialize in and how it should behave.

7. Creating Your First Skill

Skills are Python functions your agent can call. They are how you extend Hermes beyond basic chat. Here is a minimal example — a skill that checks the weather:

# skills/weather.py
from hermes_agent import skill

@skill(
    name="get_weather",
    description="Get the current weather for a city"
)
def get_weather(city: str) -> str:
    """Fetch weather for the given city."""
    import requests
    resp = requests.get(
        f"https://wttr.in/{city}?format=3"
    )
    return resp.text

Register the skill in your config:

skills:
  - path: skills/weather.py

Restart the agent, then ask it What is the weather in Tokyo? — it will automatically call your skill and return the result. The agent decides when to use a skill based on the description you provide, so write clear descriptions.

You can create skills for anything: querying databases, sending notifications, calling APIs, processing files, running scripts. Each skill is just a decorated Python function in the skills/ directory.

8. Want to Skip the Setup?

Self-hosting is great for learning and full control, but it means you own the maintenance: updates, uptime, backups, and debugging. If you just want a working Hermes Agent without the DevOps overhead, Rapid Claw handles all of it.

Deploy Hermes on Rapid Claw in 1 click. Same agent, same skills system, same multi-platform support — we just handle the infrastructure so you can focus on building.