How to Build a Customer Support Agent With Hermes Agent

Gartner projects conversational AI will reduce contact center labor costs by $80 billion in 2026. The per-contact economics make the case clear: self-service interactions cost a median of $1.84, compared to $13.50 for agent-assisted contacts. Yet the average chatbot resolution rate across all industries sits at 44.8% according to Comm100, meaning more than half of automated conversations still escalate to a human.

The gap between those cost savings and actual deployment is a tooling problem. Traditional support chatbots follow predetermined decision trees. They handle password resets and order tracking well enough. They fall apart the moment a customer asks something the flow chart never anticipated, and that happens in most conversations.

Nous Research Hermes Agent takes a different approach. Instead of static rules, it runs a learning loop: after completing a complex task (typically 5+ tool calls), the agent creates a skill, a structured document capturing the resolution steps, edge cases, and verification procedures it discovered along the way. Skills self-improve during use. If the agent finds a better response pattern while handling a ticket, it updates the skill automatically for next time.

For customer support, this means your agent improves at resolving tickets without manual retraining. Persistent cross-session memory builds profiles for returning customers. Subagent delegation handles parallel conversations without blocking. And the messaging gateway connects to 26 platforms (Telegram, Discord, Slack, WhatsApp, Signal, email, Microsoft Teams, and more) through a single background process.

The rest of this guide covers the full setup: installing Hermes Agent, connecting support channels, building skills that compound over time, delegating complex tickets, and adding persistent storage so support artifacts survive across sessions.

Install Hermes Agent on Linux, macOS, or WSL2 with the one-line installer:

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

The installer bundles Python, Node.js, and dependencies. Once installed, run the interactive setup to configure your LLM provider:

hermes setup

Hermes works with over 200 models through Nous Portal, OpenRouter, OpenAI, or custom endpoints. For support workloads with frequent tool use, models with strong instruction-following tend to produce more consistent responses. Nous Portal bundles model access with web search, image generation, and cloud browsing through a single subscription.

Connect the Messaging Gateway

The gateway is a single background process that routes conversations across all configured platforms. For a support agent, you likely want at least one customer-facing channel (Telegram, Discord, or WhatsApp) and one internal channel (Slack or Microsoft Teams) for escalation.

Run the interactive gateway wizard:

hermes gateway setup

The wizard walks through platform selection and credential entry. For Telegram, you need a bot token from @BotFather and your numeric user ID from @userinfobot. For Slack, you register an app in your workspace and provide the bot token. For Discord, you create a bot application in the Discord Developer Portal.

Each platform gets its own environment variables in ~/.hermes/.env:

TELEGRAM_BOT_TOKEN=your_token_here
TELEGRAM_ALLOWED_USERS=admin_user_id
SLACK_BOT_TOKEN=xoxb-your-slack-bot-token
DISCORD_BOT_TOKEN=your_discord_token

Security for Public-Facing Support

Running a support bot means exposing it to unknown users, so access control matters. Hermes denies all unrecognized users by default. Unknown contacts who DM the bot receive a one-time pairing code that expires after one hour. You approve requests from the CLI:

hermes pairing approve telegram XKGH5N7P

For broader access, set a catch-all allowlist with GATEWAY_ALLOWED_USERS in your environment file. Hermes supports two permission tiers per scope (DM and group channels):

• Admin gets full access to all slash commands and gated capabilities
• Regular user can chat normally but is restricted to explicitly enabled commands

This two-tier system lets you give customers normal chat access while reserving admin commands (model switching, skill management, background tasks) for your internal team. Inspect your current tier in any chat with the /whoami command.

Run as a Persistent Service

For production support, install the gateway as a system service so it survives reboots:

hermes gateway install

On Linux, this creates a systemd user service. On macOS, it creates a launchd plist. For headless servers that need boot-time startup without user login, use sudo hermes gateway install --system on Linux. Check status anytime with hermes gateway status.

Skills are how Hermes Agent turns experience into reusable knowledge. Each skill is a structured markdown document following the agentskills.io open standard, containing procedures, edge cases, and verification steps the agent learned during real interactions.

The learning loop works like this: after the agent resolves a support ticket that required multiple steps, it generates a skill capturing the resolution pattern. The next time a similar question arrives, Hermes loads the relevant skill instead of reasoning from scratch. This progressive disclosure pattern keeps token usage low because the agent only loads skills relevant to the current conversation.

For customer support, your agent builds an expanding knowledge base organically. A customer asks how to reset their API key. The agent works through it, and a skill gets created. The tenth customer who asks that question gets a faster, more accurate response because the skill has been refined through nine prior interactions.

Hermes Agent v0.8.0 introduced GEPA (Generic Evolution of Prompt Architectures), an ICLR 2026 Oral-accepted technique that makes agents 40% faster at repeated tasks. For high-volume support where the same question categories recur daily, that speed gain translates directly into reduced resolution times and lower inference costs.

Seed Your Agent With Domain Knowledge

While Hermes creates skills autonomously, you can accelerate the process by pre-loading support-specific knowledge. The /skills command in any messaging channel lets you browse and manage the agent's skill library. The Skills Hub at agentskills.io hosts community-contributed skills you can import.

For a support agent, consider seeding skills for:

• Product FAQs and common troubleshooting steps
• Escalation criteria defining when to hand off to a human
• Response tone guidelines specific to your brand
• Platform-specific behavior like file size limits in Telegram or thread handling in Slack

Connect External Knowledge Through MCP

Hermes connects to any MCP server for extended capabilities. If your product documentation lives behind an API, the agent can query it during support conversations instead of relying on stale training data. Add servers to ~/.hermes/config.yaml:

mcp_servers:
  product_docs:
    url: "https://your-docs-mcp-endpoint.com"
    headers:
      Authorization: "Bearer your_token"

Tool filtering lets you expose only read operations to the support agent, preventing accidental writes to production systems:

mcp_servers:
  product_docs:
    url: "https://your-docs-mcp-endpoint.com"
    tools:
      include: [search_docs, get_article]

This keeps answers grounded in current documentation rather than cached responses. When a customer asks about a feature, the agent fetches the latest docs through MCP rather than relying on whatever it learned during training.

Give your support agent persistent file storage

Fastio's Business Trial includes 50 GB of storage, included credits, and an MCP endpoint your Hermes Agent reads and writes to directly. No credit card required.

Start 14-Day Trial

Not every support ticket fits a single-turn response. A customer reporting a billing discrepancy might need the agent to check account records, review transaction logs, and draft a resolution while other customers wait in the queue. Hermes Agent's subagent delegation handles this without blocking the main conversation.

The delegate_task tool spawns isolated child agents with their own conversation context and restricted toolsets. Each subagent starts with zero knowledge of the parent's history. You pass everything it needs through goal and context parameters:

delegate_task(
    goal="Investigate billing discrepancy for account #12345",
    context="Customer reports double charge on May invoice. Check transaction logs and prepare a summary.",
    toolsets=["web", "file"]
)

Context isolation is intentional. It prevents token bloat from cascading through the delegation tree and keeps each child focused. Only the final summary re-enters the parent's context, not intermediate tool calls or reasoning steps.

For high-volume periods, batch delegation runs multiple investigations in parallel:

delegate_task(tasks=[
    {"goal": "Research pricing for enterprise tier", "toolsets": ["web"]},
    {"goal": "Pull usage stats for workspace ABC", "toolsets": ["file"]},
    {"goal": "Draft response to feature request #789", "toolsets": ["file"]}
])

Hermes runs up to 3 concurrent subagents per batch by default. Toolset restrictions add a security layer: a research subagent with only ["web"] cannot modify your filesystem or execute commands, keeping the blast radius contained.

The /background command in messaging channels provides another pattern for non-blocking work. A customer sends a complex request through Telegram, and the agent pushes it to a background session, freeing the main conversation thread for other customers. The background task posts results back to the originating chat when complete.

Escalation to Human Agents

Subagent delegation does not replace human judgment. For tickets involving legal questions, billing disputes above a threshold, or anything requiring account-level authority, the agent should escalate. Encode escalation criteria into skills so the agent learns which ticket categories need human review instead of autonomous resolution.

When a ticket requires human attention, the agent can summarize its investigation and route the conversation to your internal Slack or Teams channel. Because the gateway supports multiple platforms simultaneously, a customer contact on Telegram can trigger an escalation notification on Slack with full context attached.

Support interactions generate files: error screenshots, log exports, PDF invoices, configuration files customers share for troubleshooting. By default, Hermes Agent stores these on the host machine's filesystem. That works for development, but production support needs files that persist across container restarts, remain accessible to team members on different platforms, and support search across historical tickets.

Your options for external storage fall into three categories. Object storage like AWS S3 or Google Cloud Storage scales well but requires custom integration and offers no built-in semantic search. Consumer cloud storage like Google Drive or Dropbox handles basic file persistence but lacks agent-native APIs. Workspace platforms designed for agent workflows provide storage along with search, RAG, and handoff features that support operations need.

Fastio fits the third category. Its MCP server connects directly to Hermes Agent, giving your support bot read and write access to shared workspaces. Add it to your MCP configuration in ~/.hermes/config.yaml:

mcp_servers:
  fastio:
    url: "/storage-for-agents/"
    headers:
      Authorization: "Bearer YOUR_FASTIO_API_KEY"

See the Fastio MCP guide for current authentication details and the full tool surface.

Once connected, your support agent can upload customer attachments, store resolution notes, and organize artifacts by workspace. When Intelligence Mode is enabled on a workspace, every uploaded file gets automatically indexed for semantic search and RAG chat. Your agent can answer questions like "what did we tell this customer about their configuration issue last month?" by searching stored support interactions with citation-backed answers.

The Business Trial includes 50 GB of storage, included credits, 5 workspaces, and full MCP access. No credit card required, no trial expiration. For most support operations starting out, that covers thousands of ticket artifacts.

Hand Off to Human Support Leads

Fastio's ownership transfer feature lets the agent build a workspace of organized support documentation, then hand it to a human team lead. The agent keeps admin access for ongoing file management while the human owner gains full control. This works well for support teams where the AI agent triages and documents while humans make final decisions on escalated cases.

For teams already using a helpdesk platform, webhooks let you trigger actions when files change in a workspace. A new support artifact uploaded by the agent can fire a webhook to your ticketing system, creating a linked record without manual data entry.