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

Product managers spend a surprising amount of time on work that looks the same every week. Pull feedback, group it by theme, update the roadmap, write the changelog, draft an announcement, refresh the help docs. The tasks are predictable. The cost is context switching — jumping between dashboards, copy-pasting between tools, losing focus on the decisions that actually move the product forward.

What if an agent could handle the operational side while you focused on strategy?

Hermes Agent from Nous Research is a self-improving AI agent that runs on your infrastructure and learns from its own experience. Userorbit is an AI-first product growth platform that centralizes analytics, feedback, roadmaps, announcements, tours, and help docs. Connect them with a single skill and you get an autonomous AI Product Manager that runs around the clock.

This guide walks through what Hermes is, how to get it running, and how to wire it to Userorbit so it can handle real product management workflows from day one.

What Hermes Agent actually is

Hermes is not a chat wrapper around a single model. It is a full runtime for autonomous agents — with tools, memory, and a learning loop that creates reusable skills from every task it performs.

It 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.

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.

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
hermes skills install openai/skills/k8s
hermes skills tap add myorg/skills-repo

This is where Userorbit comes in.

What Userorbit brings to the table

Userorbit is an all-in-one growth stack for product teams. It combines analytics, feedback, roadmaps, announcements, knowledge base, tours, and more into a single platform. It connects to your GitHub repo and codebase, automatically builds a structured product model, and uses AI to draft changelog entries, help doc updates, tours, announcements, and surveys for each meaningful deploy.

From a product management perspective, this means:

• Product analytics — feature adoption, user journeys, engagement, retention. You see what users actually do.
• Feedback and requests — capture polls, reactions, and user requests. Aggregate them onto roadmaps and boards.
• Engagement channels — announcements, knowledge base articles, automated emails, in-app messages, customer portals.
• Onboarding and tours — product guides, checklists, and personalized tours to accelerate activation.

Userorbit's AI layer ties all of these surfaces directly to your repository. Each deploy is classified by impact and used to draft updates across changelog, docs, tours, announcements, and surveys. You review and publish from a single queue.

This makes Userorbit the right data and action plane for an AI PM: all the signals (analytics, feedback, feature requests), all the surfaces (docs, announcements, tours, emails, surveys), and a uniform API to manage them.

The Userorbit skill

The Userorbit skill teaches an agent how to call the Userorbit REST API to manage every major resource in your workspace. Natural language in, API calls out:

• "Publish an announcement about the dark mode feature we just shipped."
• "Show all feedback tagged as high priority and group it by feature."
• "Move the API v2 topic to Done on the public roadmap and notify subscribers."
• "Draft a help article explaining how to set up SSO and add it to the appropriate collection."

The skill covers the full API surface: feedback, announcements, roadmaps, and help center resources — including create, list, update, archive, vote, comment, and organize operations.

Because Hermes supports the same agentskills.io standard, the Userorbit skill can be packaged as a Hermes-compatible Agent Skill and installed via the skills system. Once installed, Hermes gains:

• Knowledge of how Userorbit models products, users, and feedback.
• Endpoints and procedures for manipulating Userorbit resources safely.
• Recommended workflows for triaging signals and communicating changes.

This is the link that turns Hermes from a generic agent into an AI PM that is fluent in your product data.

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 Userorbit, get familiar with skills:

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.

Wiring Hermes to Userorbit

1. Install the Userorbit skill

Add the Userorbit skills repository as a tap, then install:

hermes skills tap add userorbit/skill-repo
hermes skills search userorbit
hermes skills inspect userorbit/skill/userorbit-ai-pm
hermes skills install userorbit/skill/userorbit-ai-pm

Once installed, Hermes has a SKILL.md describing how to authenticate to Userorbit and how to safely call the REST API for feedback, announcements, roadmaps, and docs.

2. Configure authentication

The skill declares required environment variables in its metadata block. Set them in your shell or Hermes's environment management:

export USERORBIT_API_KEY=sk_live_...
export USERORBIT_WORKSPACE_ID=your-workspace-id

The goal: Hermes can authenticate, scope operations to the correct workspace, and avoid destructive actions unless explicitly requested.

3. 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.

Workflows: what your AI PM can do on day one

Once Hermes is running with the Userorbit skill installed and auth configured, you can start offloading real work. Here are practical patterns organized by cadence.

Daily: inbox zero for feedback

Start each day with a Customer Signals Digest:

> Using the Userorbit skill, pull all new feedback, reactions,
  and survey responses from the last 24 hours. Group them by
  feature and segment. Highlight churn risks and high-impact
  opportunities. Summarize in under 10 bullet points and
  propose concrete follow-ups.

The skill lists feedback items and reactions created in the past day, groups them by board, tag, or feature, and surfaces patterns like recurring bugs or UX issues.

Hermes's memory reinforces recurring themes over time. It can also save this triage workflow as a new skill, making it more efficient the longer it runs.

Weekly: data-backed roadmap reviews

Turn Hermes into a roadmap copilot once a week:

> Use the Userorbit skill to pull the current roadmap for the
  next two quarters, along with vote counts, comment volume,
  and associated feedback. Identify the top 5 items with the
  highest combined user demand and strategic impact. For each,
  suggest whether to accelerate, keep, or de-prioritize.

The skill fetches roadmap topics, stages, and metrics from Userorbit. Hermes cross-references with feedback and poll data, then proposes prioritization decisions with clear reasoning.

You can follow up by having Hermes draft an internal update or a public roadmap changelog entry — all via the Userorbit APIs.

Release-driven: automating announcements and docs

Userorbit already detects code changes from your repository and drafts changelog entries, doc updates, tours, announcements, and surveys per deploy. Hermes sits on top as the editorial layer:

1. Fetch the latest deploys and their auto-drafted items from Userorbit.
2. Rewrite changelog entries in your brand voice.
3. Verify help center updates are consistent and complete.
4. Decide which features deserve in-app announcements vs. email vs. just docs.
5. Push approved drafts back as ready-to-publish artifacts.

> Review the drafts Userorbit generated for the last deploy.
  Make the changelog more user-friendly, ensure the help doc
  explains what changed and why it matters, and craft a short
  in-app announcement for power users only. Mark everything
  ready for review — do not auto-publish.

Encode this workflow as a skill and Hermes refines it over time, including guardrails like "never publish without human approval."

Always-on: scheduled briefings and watches

Hermes includes natural-language cron scheduling. With the Userorbit skill, this unlocks always-on PM behaviors:

• Weekly Retention Briefing — broken down by cohort and key features.
• Churn Risk Watchlist — flagged by negative feedback trends and drop-offs in key journeys.
• Feature Adoption Tracker — alerts when a shipped feature misses expected adoption targets after a set period.

All expressed as scheduled Hermes commands that call into Userorbit, process results, and send concise summaries to Telegram, Slack, or email.

Prompt patterns you can use today

Strategy and prioritization

• "Using Userorbit analytics and feedback, what are the top three friction points for new users in the last 30 days? Propose experiments to address them."
• "Look at roadmap items tagged 'Enterprise' and feedback from accounts with more than 50 seats. Which features are blocking expansion, and what should we prioritize next quarter?"

Feedback triage

• "Cluster the last 200 feedback items into themes. Label each cluster, estimate user impact, and suggest whether it belongs on the roadmap, in a quick fix queue, or in docs."
• "Find all feedback mentioning 'billing' or 'invoice' with negative sentiment. Summarize the core problems and suggest an FAQ outline to address them."

Communication and docs

• "Given the features shipped in the last two weeks, draft a single 'What's new' email that speaks to admins, PMs, and end users differently. Pull concrete examples from Userorbit's changelog and docs data."
• "Scan the knowledge base for articles that reference deprecated settings. List the top 10 that need refreshing and explain what should change."

Experimentation

• "Using Userorbit funnels, identify where users drop off between sign-up and first key action. Suggest two onboarding tweaks and one in-app message experiment to improve activation."

These prompts become more powerful when encoded as skills. Hermes can execute them as named commands rather than freeform chat.

Best practices and guardrails

Granting an autonomous agent write access to product tooling requires care. A few levers to keep your AI PM safe:

• Use trust levels. Prefer builtin, official, or trusted sources for sensitive skills. For community skills, run hermes skills audit and review findings before enabling destructive operations.
• Scope your API keys. Use workspace- or environment-scoped keys for Userorbit. Avoid granting broader access than necessary.
• Start in read-only mode. Configure the Userorbit skill to only read data and draft artifacts initially. Add write capabilities later with explicit approval steps.
• Log and review. Use Hermes's audit logging and Userorbit's activity logs to trace what the AI PM is doing over time.
• Iterate on skills. Treat skills like code: version them, review diffs, and refine prompts based on observed behavior.

With these guardrails, Hermes plus a well-designed Userorbit skill can handle a surprising amount of day-to-day product work safely.

An agent runtime, a product data plane, and a skill that glues them together

The operational side of product management is predictable. Pull signals, interpret them, decide what to do, communicate the outcome. An AI agent with the right tools and the right data can handle most of it autonomously.

Hermes provides the runtime: an agent that improves over time, delegates work, and remembers what it learned. Userorbit provides the data plane: every signal and every surface a PM needs, behind a single API. The skill is the bridge.

Set it up once. Let it learn. Check in on the outputs. Ship faster because the operational overhead is handled.

Where to go next

• Hermes Agent documentation — skills, memory, automation
• Agent Skills ecosystem — designing robust, interoperable skills
• Userorbit AI-first product growth — how Userorbit classifies deploys and drafts multi-channel communication
• Managing Userorbit with coding agents — the reference guide for the Userorbit skill