TL;DR

• Hermes Agent is an open source, self-improving AI agent built by Nous Research. It is MIT licensed and free to run. You pay only for the model tokens you use.

• Unlike coding-only harnesses, Hermes is a general autonomous agent with a built-in learning loop: it creates skills from experience, improves them during use, and remembers you across sessions.

• It runs anywhere, from your laptop to a $5 VPS to serverless infrastructure, and lives where you do: CLI, Telegram, Discord, Slack, WhatsApp, and 20+ other platforms.

• It is model-agnostic, with 30+ supported providers plus any OpenAI-compatible endpoint.

• Pointing Hermes at Pioneer for inference takes four config commands and gives you Claude, GPT, Gemini, and open models behind one endpoint, with inference logs and a feedback loop that fine-tunes your model against live production traffic.

The agent space split into two camps in 2026. On one side are coding harnesses that live in your terminal, do excellent work on your repo, and forget everything the moment a session ends. On the other side is a newer idea: one agent that runs continuously, learns from every session, and follows you from your terminal to your phone. Hermes Agent is the most prominent open source bet on that second camp, and its GitHub repo has climbed to 210,000 stars.

This guide covers what Hermes Agent is, how to install and configure it, how it compares to OpenClaw, Claude Code, OpenCode, and Devin, and how to run inference through Pioneer so you can reach many models across providers behind a single endpoint.

What is Hermes Agent?

Hermes Agent is an open source autonomous AI agent built by Nous Research, the lab behind the Hermes model family. It is MIT licensed, ships as a CLI and a desktop app for macOS, Windows, and Linux, and describes itself as "the agent that grows with you."

That tagline points at the real differentiator: a built-in learning loop. Hermes creates skills from experience, improves those skills while using them, nudges itself to persist what it learns, and builds a deepening model of who you are across sessions. Session history lives in a local database with full-text search, so when you reference past work in a new chat, the agent can recall it. The practical result is that the agent you run on day 30 is more capable than the one you installed on day 1.

One important distinction before we go further: Hermes is not only a coding agent. It reads and edits files, runs shell commands, and works through multi-step tasks on your codebase like a coding harness does. But it also browses the web, runs scheduled automations, answers you on messaging apps, and handles research and personal workflows. If you are comparing it head-to-head with a dedicated coding tool, that generality is the trade-off to understand, and we cover it in the comparison section below.

It is also not tied to your laptop. Hermes supports six terminal backends: local, Docker, SSH, Daytona, Singularity, and Modal. The serverless options (Daytona, Modal) hibernate when idle, so an always-on agent can cost nearly nothing between tasks. You can talk to it from Telegram while it works on a cloud VM you never SSH into yourself.

Key features of Hermes Agent

• The learning loop. The headline feature. Agent-curated memory with periodic nudges, autonomous skill creation, skill self-improvement during use, and cross-session recall backed by full-text search. No other mainstream agent ships this as a first-class, built-in system.

• Skills. Skills are on-demand instruction documents, each a SKILL.md file with a name, description, and step-by-step procedure. Hermes ships with a bundled catalog, can install more from the community Skills Hub, and creates its own from tasks you repeat. Every installed skill becomes a slash command automatically. Skills follow the open standard at agentskills.io, so they are portable and shareable.

• Persistent memory. Memory holds facts: your environment, preferences, and what the agent has learned about you. It is intentionally bounded, and the agent consolidates entries when it fills up. Memory is for "what," skills are for "how."

• Model flexibility. Hermes works with 30+ providers, from Anthropic and OpenAI to OpenRouter, Hugging Face, AWS Bedrock, and local runtimes, plus any OpenAI-compatible endpoint. Switch models mid-session with /model.

• A messaging gateway. One agent, one memory, 20+ platforms: Telegram, Discord, Slack, WhatsApp, Signal, Email, Microsoft Teams, and more. Set it up once with hermes gateway setup and your agent answers wherever you already are.

• 60+ built-in tools. Terminal, file operations, web search, browser control, vision, image generation, and text-to-speech, all configurable per platform.

• Scheduled automations. Built-in cron with delivery to any connected platform. A morning briefing in Telegram or a nightly repo check in Slack is configuration, not code.

• Delegation and parallel work. Hermes spawns isolated subagents for parallel workstreams, and its execute_code tool collapses multi-step pipelines into single inference calls.

• MCP and editor support. Connect any Model Context Protocol server for extended tools, and integrate with editors through ACP with a single hermes acp command.

• Context files. AGENTS.md gives the agent durable project context, a global SOUL.md defines its default voice, and existing .cursorrules files are read automatically, so you keep conventions you already wrote.

How to set up Hermes Agent (step by step)

To run Hermes with a model you don't host yourself, you'll need a terminal and either an API key or an OAuth-based provider account. You can also run Hermes with local models you host. One requirement to know up front: Hermes needs a model with at least 64,000 tokens of context, which every major hosted model meets easily.

1. Install Hermes Agent

On macOS or Windows, the easiest path is the Hermes Desktop installer, which installs both the desktop and command-line apps.

For a CLI-only install on Linux, macOS, WSL2, or Android (Termux):

curl -fsSL <https://hermes-agent.nousresearch.com/install.sh> | bash

curl -fsSL <https://hermes-agent.nousresearch.com/install.sh> | bash

curl -fsSL <https://hermes-agent.nousresearch.com/install.sh> | bash

On native Windows, run in PowerShell:

iex (irm <https://hermes-agent.nousresearch.com/install.ps1>)

iex (irm <https://hermes-agent.nousresearch.com/install.ps1>)

iex (irm <https://hermes-agent.nousresearch.com/install.ps1>)

Then reload your shell:

source ~/.bashrc   # or source ~/.zshrc

source ~/.bashrc   # or source ~/.zshrc

source ~/.bashrc   # or source ~/.zshrc

2. Choose a provider

This is the most important setup step. Run the interactive picker:

On a fresh install, hermes setup offers three modes: Quick Setup (OAuth login through Nous Portal, no API keys), Full Setup (walk through every provider and option with your own keys), and Blank Slate (a minimal agent where everything starts off and you opt in to exactly what you want).

Hermes stores secrets in ~/.hermes/.env and non-secret settings in ~/.hermes/config.yaml, and hermes config set routes each value to the right file automatically. You can switch providers at any time, so nothing you pick here locks you in.

The fastest way to get many models behind one key is Pioneer, so that is where we go next.

How to run inference through Pioneer in Hermes Agent

Pioneer is an inference API that is drop-in compatible with your existing OpenAI or Anthropic client. Point Hermes at it and you get access to a range of models across the Claude, GPT, and Gemini families through one endpoint, full inference logs, and a feedback loop that turns your production traffic into a sharper, cheaper model over time. Your weights and training data stay yours, and the optimization is included at no extra cost.

• Grab your Pioneer API key at agent.pioneer.ai

• Open a new terminal and set your API key:

export PIONEER_API_KEY="<Your Pioneer API key>"

export PIONEER_API_KEY="<Your Pioneer API key>"

export PIONEER_API_KEY="<Your Pioneer API key>"

• Run this one-time setup command that:

  • fetches the live GET /v1/models catalog,

  • filters out Claude Code discovery aliases,

  • stores your Pioneer API key in Hermes’ local environment file at ~/.hermes/.env,

  • writes the filtered Pioneer provider to ~/.hermes/config.yaml, and

  • sets pioneer/auto as the default model so Pioneer can route each request automatically.

: "${PIONEER_API_KEY:?Set PIONEER_API_KEY first}"

command -v jq >/dev/null || { echo "jq is required"; exit 1; }
command -v ruby >/dev/null || { echo "ruby is required"; exit 1; }

CONFIG_FILE="$(hermes config path)"
CONFIG_TMP="$(mktemp)"
MODELS_JSON="$(mktemp)"
trap 'rm -f "$CONFIG_TMP" "$MODELS_JSON"' EXIT

mkdir -p "$(dirname "$CONFIG_FILE")"
[ -f "$CONFIG_FILE" ] || printf '{}\n' > "$CONFIG_FILE"
cp "$CONFIG_FILE" "$CONFIG_FILE.bak.$(date +%Y%m%d%H%M%S)"

hermes config set PIONEER_API_KEY "$PIONEER_API_KEY"

curl -fsS "<https://api.pioneer.ai/v1/models>" \
  -H "Authorization: Bearer $PIONEER_API_KEY" \
  | jq '
    def dedupe:
      reduce .[] as $item ([]; if index($item) then . else . + [$item] end);

    def catalog_models:
      (.models // []) as $models
      | if (($models | type) == "array" and ($models | length) > 0) then $models else (.data // []) end;

    def model_id:
      .slug // .id;

    (["pioneer/auto"] + [
      catalog_models[]
      | select(.deprecated != true)
      | model_id
      | select(type == "string" and length > 0)
      # Hide Claude Code discovery aliases so Hermes does not show every model twice.
      | select(startswith("anthropic/") | not)
      | select(. != "pioneer/auto" and . != "auto")
    ]) | dedupe
  ' > "$MODELS_JSON"

ruby -ryaml -rjson -e '
  config_path, models_path, out_path = ARGV
  cfg = File.exist?(config_path) ? (YAML.safe_load(File.read(config_path), aliases: true) || {}) : {}
  abort "#{config_path} must contain a YAML mapping" unless cfg.is_a?(Hash)

  models = JSON.parse(File.read(models_path))
  cfg["providers"] = {} unless cfg["providers"].is_a?(Hash)
  cfg["providers"]["pioneer"] = {
    "name" => "Pioneer",
    "base_url" => "<https://api.pioneer.ai/v1>",
    "key_env" => "PIONEER_API_KEY",
    "api_mode" => "chat_completions",
    "discover_models" => false,
    "default_model" => "pioneer/auto",
    "models" => models
  }

  cfg["model"] = {} unless cfg["model"].is_a?(Hash)
  cfg["model"]["provider"] = "pioneer"
  cfg["model"]["default"] = "pioneer/auto"
  cfg["model"]["base_url"] = "<https://api.pioneer.ai/v1>"
  cfg["model"]["api_mode"] = "chat_completions"

  File.write(out_path, YAML.dump(cfg))
' "$CONFIG_FILE" "$MODELS_JSON" "$CONFIG_TMP"

mv "$CONFIG_TMP" "$CONFIG_FILE"
chmod 600 "$CONFIG_FILE"

: "${PIONEER_API_KEY:?Set PIONEER_API_KEY first}"

command -v jq >/dev/null || { echo "jq is required"; exit 1; }
command -v ruby >/dev/null || { echo "ruby is required"; exit 1; }

CONFIG_FILE="$(hermes config path)"
CONFIG_TMP="$(mktemp)"
MODELS_JSON="$(mktemp)"
trap 'rm -f "$CONFIG_TMP" "$MODELS_JSON"' EXIT

mkdir -p "$(dirname "$CONFIG_FILE")"
[ -f "$CONFIG_FILE" ] || printf '{}\n' > "$CONFIG_FILE"
cp "$CONFIG_FILE" "$CONFIG_FILE.bak.$(date +%Y%m%d%H%M%S)"

hermes config set PIONEER_API_KEY "$PIONEER_API_KEY"

curl -fsS "<https://api.pioneer.ai/v1/models>" \
  -H "Authorization: Bearer $PIONEER_API_KEY" \
  | jq '
    def dedupe:
      reduce .[] as $item ([]; if index($item) then . else . + [$item] end);

    def catalog_models:
      (.models // []) as $models
      | if (($models | type) == "array" and ($models | length) > 0) then $models else (.data // []) end;

    def model_id:
      .slug // .id;

    (["pioneer/auto"] + [
      catalog_models[]
      | select(.deprecated != true)
      | model_id
      | select(type == "string" and length > 0)
      # Hide Claude Code discovery aliases so Hermes does not show every model twice.
      | select(startswith("anthropic/") | not)
      | select(. != "pioneer/auto" and . != "auto")
    ]) | dedupe
  ' > "$MODELS_JSON"

ruby -ryaml -rjson -e '
  config_path, models_path, out_path = ARGV
  cfg = File.exist?(config_path) ? (YAML.safe_load(File.read(config_path), aliases: true) || {}) : {}
  abort "#{config_path} must contain a YAML mapping" unless cfg.is_a?(Hash)

  models = JSON.parse(File.read(models_path))
  cfg["providers"] = {} unless cfg["providers"].is_a?(Hash)
  cfg["providers"]["pioneer"] = {
    "name" => "Pioneer",
    "base_url" => "<https://api.pioneer.ai/v1>",
    "key_env" => "PIONEER_API_KEY",
    "api_mode" => "chat_completions",
    "discover_models" => false,
    "default_model" => "pioneer/auto",
    "models" => models
  }

  cfg["model"] = {} unless cfg["model"].is_a?(Hash)
  cfg["model"]["provider"] = "pioneer"
  cfg["model"]["default"] = "pioneer/auto"
  cfg["model"]["base_url"] = "<https://api.pioneer.ai/v1>"
  cfg["model"]["api_mode"] = "chat_completions"

  File.write(out_path, YAML.dump(cfg))
' "$CONFIG_FILE" "$MODELS_JSON" "$CONFIG_TMP"

mv "$CONFIG_TMP" "$CONFIG_FILE"
chmod 600 "$CONFIG_FILE"

: "${PIONEER_API_KEY:?Set PIONEER_API_KEY first}"

command -v jq >/dev/null || { echo "jq is required"; exit 1; }
command -v ruby >/dev/null || { echo "ruby is required"; exit 1; }

CONFIG_FILE="$(hermes config path)"
CONFIG_TMP="$(mktemp)"
MODELS_JSON="$(mktemp)"
trap 'rm -f "$CONFIG_TMP" "$MODELS_JSON"' EXIT

mkdir -p "$(dirname "$CONFIG_FILE")"
[ -f "$CONFIG_FILE" ] || printf '{}\n' > "$CONFIG_FILE"
cp "$CONFIG_FILE" "$CONFIG_FILE.bak.$(date +%Y%m%d%H%M%S)"

hermes config set PIONEER_API_KEY "$PIONEER_API_KEY"

curl -fsS "<https://api.pioneer.ai/v1/models>" \
  -H "Authorization: Bearer $PIONEER_API_KEY" \
  | jq '
    def dedupe:
      reduce .[] as $item ([]; if index($item) then . else . + [$item] end);

    def catalog_models:
      (.models // []) as $models
      | if (($models | type) == "array" and ($models | length) > 0) then $models else (.data // []) end;

    def model_id:
      .slug // .id;

    (["pioneer/auto"] + [
      catalog_models[]
      | select(.deprecated != true)
      | model_id
      | select(type == "string" and length > 0)
      # Hide Claude Code discovery aliases so Hermes does not show every model twice.
      | select(startswith("anthropic/") | not)
      | select(. != "pioneer/auto" and . != "auto")
    ]) | dedupe
  ' > "$MODELS_JSON"

ruby -ryaml -rjson -e '
  config_path, models_path, out_path = ARGV
  cfg = File.exist?(config_path) ? (YAML.safe_load(File.read(config_path), aliases: true) || {}) : {}
  abort "#{config_path} must contain a YAML mapping" unless cfg.is_a?(Hash)

  models = JSON.parse(File.read(models_path))
  cfg["providers"] = {} unless cfg["providers"].is_a?(Hash)
  cfg["providers"]["pioneer"] = {
    "name" => "Pioneer",
    "base_url" => "<https://api.pioneer.ai/v1>",
    "key_env" => "PIONEER_API_KEY",
    "api_mode" => "chat_completions",
    "discover_models" => false,
    "default_model" => "pioneer/auto",
    "models" => models
  }

  cfg["model"] = {} unless cfg["model"].is_a?(Hash)
  cfg["model"]["provider"] = "pioneer"
  cfg["model"]["default"] = "pioneer/auto"
  cfg["model"]["base_url"] = "<https://api.pioneer.ai/v1>"
  cfg["model"]["api_mode"] = "chat_completions"

  File.write(out_path, YAML.dump(cfg))
' "$CONFIG_FILE" "$MODELS_JSON" "$CONFIG_TMP"

mv "$CONFIG_TMP" "$CONFIG_FILE"
chmod 600 "$CONFIG_FILE"

<aside>
💡

pioneer/auto is Pioneer’s model router that automatically picks the right model for each coding task, weighing cost, latency, and accuracy, so you're not switching models manually or stuck with the most expensive ones. Learn more about the router here or read the docs.

</aside>

• Start Hermes:

• Switch between saved Pioneer models with /model inside Hermes. Use -global when you want the change to persist in ~/.hermes/config.yaml:

The integration steps also live in the Pioneer Hermes docs.

Why use Pioneer with Hermes Agent

Hermes is built to switch models mid-session, and Pioneer makes every switch the same key and the same endpoint instead of another provider account. Behind one base URL you get frontier models from Anthropic, OpenAI, and Google alongside open models, so you can route a fast, inexpensive model at formatting tasks and a reasoning model at architecture decisions without juggling credentials.

The pairing runs deeper than convenience. Hermes improves at the harness layer: it learns skills, consolidates memory, and gets better at working with you. Pioneer improves at the model layer: Adaptive Inference clusters your responses by task, diagnoses failures, and trains smaller open-source models against your real traffic in the background. When it finds one that is cheaper and better for your use case, it alerts you, and you decide when to route traffic to it. A self-improving agent on top of self-improving inference means both halves of your stack compound.

That matters most for exactly the workloads Hermes is designed for. An always-on agent running cron jobs and answering a Telegram channel consumes tokens around the clock, not just during a coding session. Per-task model routing and a fine-tuned model that costs less per request compound daily on an agent that never sleeps.

Run your first chat and verify your setup

Your first conversation

hermes            # classic CLI
hermes --tui      # modern terminal UI

hermes            # classic CLI
hermes --tui      # modern terminal UI

hermes            # classic CLI
hermes --tui      # modern terminal UI

You will see a welcome banner with your model, tools, and skills. Start with a prompt that is specific and easy to verify:

Success looks like this: the banner shows your chosen model, the agent replies without error, it can use a tool when needed, and the conversation continues past one turn. If that works, you are past the hardest part.

Verify sessions work

hermes --continue    # resume the most recent session
hermes -c            # short form

hermes --continue    # resume the most recent session
hermes -c            # short form

hermes --continue    # resume the most recent session
hermes -c            # short form

This should drop you back into the conversation you just had. Session resume is the foundation of everything the learning loop does, so confirm it before layering anything else on.

Add the next layer

Only after a clean base chat works, pick what you need. hermes gateway setup connects Telegram, Discord, Slack, and other platforms. hermes skills browses and installs reusable workflows. hermes config set terminal.backend docker sandboxes the agent's terminal in a container. MCP servers go in ~/.hermes/config.yaml.

Hermes Agent vs other AI agents and harnesses

The tools closest to Hermes split by where they sit: self-hosted personal agents, terminal coding harnesses, and cloud autonomous engineers.

Where Hermes wins. The learning loop is the feature no one else ships as a built-in: skill creation from experience, self-improvement during use, and memory that persists across sessions. It is general-purpose rather than coding-only, it runs on anything from a phone to serverless infrastructure, and it is messaging-native from day one. It is MIT licensed with no paid tier for the tool itself.

Where the others win. OpenClaw is Hermes' closest relative, another open source self-hosted personal agent, with a larger community and skill marketplace behind it. Claude Code is the most complete agentic coding runtime on the benchmarks and the right pick if coding is the whole job. OpenCode is the model-agnostic coding harness, and if that is what you need, we wrote a complete guide to OpenCode too. Devin is the outlier: a proprietary, cloud-hosted engineer that runs long tasks on its own rather than an agent you host.

The honest guidance: many developers run Hermes alongside a coding harness rather than instead of one. A dedicated harness at the desk for deep repo work, Hermes for automations, research, and everything that happens away from the keyboard. Both can point at the same Pioneer key.

Common use cases

• Coding and repo work. Ask Hermes to summarize a codebase, fix a failing test, or set up a PR workflow. An AGENTS.md file in your project root gives it durable context about your architecture and conventions.

• A daily briefing bot. Built-in cron plus the messaging gateway means Hermes can compile a morning briefing and deliver it to Telegram on schedule. The official docs include a full tutorial.

• A team assistant in Slack or Telegram. DM pairing gives teammates one-time codes you approve, so you never manage user ID allowlists by hand.

• A GitHub PR review agent. Webhook-triggered reviews on every pull request, covered step by step in the official guide.

• Research and long-running tasks. Delegate parallel research to isolated subagents, each with its own context window, and get only the summaries back. Resume any session later by title with hermes -r.

• Personal automation without much code. If you are not a developer but want to test agentic tooling, Hermes meets you at the shallow end: plain-language tasks in a chat app you already use, clipboard image paste for screenshots, and voice mode when typing is the wrong interface.

Tips and best practices

• Be specific and front-load context. "Fix the TypeError in api/handlers.py on line 47" beats "fix the code." Paste tracebacks directly, the agent parses them.

• Invest in AGENTS.md. Recurring instructions ("we use pytest," "the API is at /api/v2") belong in a context file the agent reads every session, not in your prompts.

• Ask it to save skills. After a task that took five or more steps, say "save what you just did as a skill called deploy-staging." Next time it is a slash command.

• Route models by task. Use /model to move between a cheap model for boilerplate and a frontier model for reasoning. Through Pioneer, every option sits behind the same endpoint, and your inference logs show what each request actually did.

• Manage your context window. Run /compress when long sessions slow down, and /usage to see where your tokens go.

• Take the security defaults seriously. Use the Docker backend for untrusted code, never set GATEWAY_ALLOW_ALL_USERS=true on a bot with terminal access, and think twice before answering "always" to a dangerous-command approval.

Troubleshooting and FAQ

• Is Hermes Agent free?
  The tool is free and MIT licensed. You pay only for model tokens through whatever provider you configure.

• Is Hermes Agent a coding agent?
  It is a general autonomous agent that codes. It handles repo work well, but its distinguishing features (memory, skills, messaging, cron) target everything around and beyond coding.

• What models does Hermes Agent support?
  30+ providers out of the box, plus any OpenAI-compatible endpoint such as Pioneer. Models need at least 64K tokens of context.

• Hermes Agent vs Claude Code, which is better?
  Different jobs. Claude Code leads pure coding benchmarks and is tightly integrated with Anthropic's models. Hermes is open source, model-agnostic, and built for persistent, always-on work across surfaces. Many developers use both.

• How do I run multiple models from one place?
  Point Hermes at Pioneer. Four config commands give you Claude, GPT, Gemini, and open models behind one endpoint, with inference logs and continual optimization included.

• Hermes opens but replies are empty or broken?
  Almost always provider auth or model selection. Run hermes model again and confirm provider, model, and auth. For anything else, hermes doctor diagnoses config problems, and the docs include a recovery sequence that gets you back to a known state.

Conclusion

Hermes Agent is the open source agent for people who want their AI to accumulate capability instead of resetting every session. Install it in a minute, get one clean conversation working, and then layer on the pieces that fit your life: a Telegram gateway, a cron briefing, a skill it wrote for you last Tuesday. It is model-agnostic by design, and that is exactly where Pioneer fits. Four config commands give you every major model family behind one endpoint, full visibility into your inference, and a feedback loop that makes your model cheaper and sharper the more your agent runs.

Get a Pioneer API key at pioneer.ai, follow the Hermes integration docs, and run your first Hermes session through Pioneer today.