Getting Started with Hermes Agent: Build a 24/7 AI Product Manager

Most AI tools are chat wrappers around a single model. You type a prompt, get a response, and start over. Hermes Agent from Nous Research is different — it's a full runtime for autonomous agents that runs on your infrastructure, learns from its own experience, and extends itself with reusable skills.

This guide walks through what Hermes is, how to get it running, how its skills system works, and how to connect it to external tools so it can handle real workflows autonomously.

What Hermes Agent actually is

Hermes runs as a daemon on your own machine or server (local, Docker, SSH, serverless backends like Modal or Daytona) and exposes a TUI plus messaging gateways for Telegram, Slack, Discord, WhatsApp, Signal, and email. It has tools, memory, and a learning loop that creates reusable skills from every task it performs.

What makes Hermes interesting for product teams:

• Closed learning loop. Hermes creates and refines skills from its own experience. It persists knowledge in long-term memory and recalls past work using full-text search plus LLM summarization. The more it runs your product workflows, the better it gets at them.
• Multi-model support. Connect to Nous Portal, OpenRouter, or any OpenAI-compatible endpoint — including local models via Ollama or vLLM. Hundreds of frontier and open models available, so you can pick the cost–quality tradeoff that fits.
• 40+ built-in tools. Web search, browser automation, filesystem access, vision, image generation, code execution, subagent delegation, cron scheduling.
• Delegation and parallelism. Hermes spawns isolated subagents with their own terminals and conversations. Research, analysis, writing, and QA can run in parallel tracks.

The piece that matters most for this post: Hermes uses an open-standard skills system to extend its capabilities with reusable, portable instruction modules.

Why Hermes over other agent runtimes

If you're comparing Hermes to platforms like OpenClaw, the key difference is philosophy. Hermes is a single self-improving agent designed for fast time-to-value for one user or team. OpenClaw is a multi-agent gateway built for orchestrating many agents across many channels with enterprise-style access controls.

Choose Hermes when you want:

• Privacy and data locality — zero telemetry by default, runs sandboxed on your infrastructure, nothing phones home unless you configure it.
• A capable agent out of the box — the integrated learning loop, memory, and opinionated tool defaults mean a fresh Hermes install is productive immediately, without architecting a multi-agent platform.
• Python-native transparency — direct agent loop architecture makes it easy to inspect and tweak each reasoning and tool-use step.
• Tight pairing with Hermes models — Nous's Hermes 3 and 4 are strong open-weight models with hybrid reasoning, and the agent is designed to work naturally with them while still supporting 200+ other models via OpenRouter and compatible endpoints.

OpenClaw is the better fit if you're building a multi-user, multi-channel system with many specialized plugins and governance requirements. For a deeper comparison, see Hermes Agent vs OpenClaw.

How skills work

A skill in Hermes is an on-demand knowledge document that the agent loads when it needs domain-specific procedures. Skills live under ~/.hermes/skills/ and follow a progressive disclosure pattern — the agent pulls in only the parts relevant to the current task, conserving tokens while keeping deep procedural guidance available when needed.

Hermes treats skills as procedural memory. With the skill_manage tool, it can create, update, and delete skills on its own whenever it discovers a reusable workflow. That means you can:

• Teach Hermes how your product and tools work once.
• Let it refine that knowledge every time it runs the workflow again.
• Share skills across agents and environments using the agentskills.io standard.

Skills follow a SKILL.md format with frontmatter (name, description, version, required environment variables) and structured sections: "When to Use," "Quick Reference," "Procedure," "Pitfalls," and "Verification." This structure is built for product work, where you want consistent SOPs for triaging feedback or publishing announcements.

You can install skills from the hub, from GitHub repos, or from custom taps:

hermes skills browse
hermes skills search userorbit/skill/userorbit
hermes skills install openai/skills/k8s
hermes skills tap add myorg/skills-repo

Skills are what make Hermes practical for real workflows. The hub and community repos cover everything from Kubernetes management to GitHub workflows. To see what this looks like in practice, let's wire Hermes to a product management platform.

Getting started: from zero to first skill

1. Install Hermes Agent

Hermes offers a one-line install script for Linux, macOS, and WSL2. It bootstraps Python, uv, and the Hermes repo without requiring sudo in most cases.

1. Run the install script from the official repository.
2. Let the installer set up Python 3.11, uv, and the Hermes environment.
3. Verify the CLI is on your PATH:

hermes --help

Hermes can run on anything from a $5 VPS to a GPU cluster or serverless containers. Start small, scale later.

2. Connect a model provider

Configure Hermes to talk to a model provider:

hermes setup    # interactive wizard
hermes model    # configure a specific model

Options include:

• Nous Portal via OAuth
• OpenRouter with an API key
• Any OpenAI-compatible endpoint — including local deployments (Ollama, vLLM)

Pick a cost–quality tradeoff that matches your workloads.

3. Start chatting

Once configured:

hermes

This drops you into a full TUI with multiline editing, slash commands, conversation history, and streaming tool output. Out of the box you get the 40+ built-in tools, bundled skills for MLOps and GitHub workflows, and persistent memory across sessions.

Prefer messaging? Add a gateway and talk to Hermes from Telegram, Discord, Slack, WhatsApp, Signal, or email while it runs on a VM or container.

4. Explore the skills system

Before adding external integrations, get familiar with the skills system:

hermes skills list           # installed skills
hermes skills browse         # hub skills
hermes skills search roadmap # find something specific
hermes skills inspect openai/skills/k8s  # review before installing
hermes skills install openai/skills/k8s  # install

Hermes assigns trust levels (builtin, official, trusted, community) and can security-scan skills for dangerous patterns like data exfiltration or destructive shell commands. This matters when you are about to give an agent write access to your product tooling.

Putting it together: Hermes + Userorbit

Userorbit is a product growth platform that centralizes analytics, feedback, roadmaps, announcements, and help docs behind a single API. It's a good example of the kind of tool Hermes can manage autonomously — multiple resource types, predictable workflows, and a REST API that a skill can teach the agent to call.

Quick setup (5 minutes)

Get Hermes talking to Userorbit in four steps:

# 1. Add the Userorbit skill
hermes skills tap add userorbit/skill-repo
hermes skills install userorbit/skill/userorbit
 
# 2. Sign up for Userorbit (free, no credit card)
#    → https://userorbit.com/signup
 
# 3. Set your credentials
export USERORBIT_API_KEY=sk_live_...      # from Settings → API Keys
export USERORBIT_WORKSPACE_ID=ws_...      # from Settings → Workspace
 
# 4. Verify it works
hermes
> List my Userorbit feedback

Here's what that last step looks like in practice:

You: List my Userorbit feedback sorted by votes

Hermes: I'll fetch your feedback from Userorbit.

 ┌ tool: http_request
 │ GET https://api.userorbit.com/v1/feedback?sort=votes&limit=10
 │ Status: 200 OK
 └

Here are your top feedback items:

 #  Title                              Votes  Status
 1  Dark mode for the dashboard          34   Under review
 2  Slack integration for feedback        28   Planned
 3  Custom fields on feedback forms       19   Under review
 4  Bulk actions for roadmap items        15   New
 5  API rate limit increase               12   New

Would you like me to triage these or update any statuses?

Once connected, Hermes can create announcements, update roadmap items, triage feedback, and draft help articles — all through natural language.

Teach Hermes your product context

Hermes already has a learning loop and long-term memory. Userorbit has a structured view of your product and users. To get the most out of an AI PM, consider:

• Adding a Hermes persona (SOUL.md) that frames the agent explicitly as a Product Manager for your product.
• Providing a Product Overview skill that explains your product, segments, pricing, and strategic priorities.
• Linking to Userorbit documentation and API reference inside the skill's "Quick Reference" section.

This helps Hermes interpret raw analytics and feedback as signals against your product strategy — not just numbers.

Go further: chain commands into workflows

Once the basics work, try multi-step instructions:

> Triage all new feedback: mark duplicates, tag by theme,
  and move anything with 10+ votes to "Under review"

> Draft an announcement about the feature I just shipped.
  Put it in "Product Updates" — don't publish yet.

> Review all help articles tagged "getting-started" and flag
  any that reference features we've since renamed or removed

Hermes translates each instruction into the correct sequence of API calls, handles pagination, and returns structured results. If something fails, it tells you what went wrong and suggests a fix.

Hermes also supports subagent delegation — spawning parallel agents that each handle a different task simultaneously. One subagent triages feedback while another drafts a changelog while a third audits help docs. Results flow back to the parent agent for synthesis.

What comes next

You now have a working Hermes Agent with the skills system configured and a practical integration running. From here:

• Go deeper with Userorbit workflows — daily feedback triage, weekly roadmap reviews, release-day automation, and prompt patterns for running Hermes as an AI PM.
• Use Userorbit with other agents — the same Userorbit skill works with Claude Code, Codex, Cursor, Copilot, and Gemini.

Reference links

• Hermes Agent documentation — skills, memory, automation
• Agent Skills ecosystem — designing robust, interoperable skills
• Userorbit — AI-first product growth platform