Setting Up Hermes Agent: AI-Powered DevOps

It's past 10 PM. I should be asleep. Instead I'm watching Hermes Agent run a health check across the Proxmox cluster and thinking about how my job has changed in the last year.

Here's the setup.

Why Hermes

I've been using AI coding agents for a while — Claude Code, Codex CLI, earlier experiments with OpenClaw. They're good at specific tasks: write this function, refactor this module, explain this error. But they're transactional. You give them a task, they do it, the session ends.

Hermes Agent is different. It's persistent. It has a profile, a memory, scheduled jobs. It runs in the background and can be reached through Discord or Telegram. It feels less like a tool I invoke and more like a team member I delegate to — one who happens to never sleep, never get bored, and never forgets a configuration detail I told it three weeks ago.

That last part matters more than I expected.

The Setup

Installing Hermes is straightforward. The harder part is configuring it for how I actually work.

# Install
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash

# Initialize profile
hermes init --profile default

# Configure model (I use a local model for cost reasons,
# frontier models for complex reasoning)
hermes config set model.local "deepseek-v3"
hermes config set model.frontier "claude-4-sonnet"

The interesting configuration is the gateways. Hermes can be reached through Discord and Telegram, which means I can send it instructions from my phone at any hour and it'll execute them on the server. This has changed how I interact with the infrastructure.

# Discord gateway config (simplified)
gateways:
  discord:
    enabled: true
    token: ${DISCORD_BOT_TOKEN}
    allowed_channels:
      - "sorren-ops"      # infrastructure channel
      - "sorren-alerts"   # monitoring alerts
  
  telegram:
    enabled: true
    token: ${TELEGRAM_BOT_TOKEN}
    allowed_users:
      - "nate_kovac"

I have a Discord channel called sorren-ops that is effectively a chat window into my server room. I can type "check GPU temps on the training rig" from my phone at dinner and get an answer in seconds. Whether that's a healthy work-life boundary is a separate question I'm choosing not to examine right now.

Scheduled Cron Jobs

This is where Hermes earns its keep. I have a set of scheduled jobs that run automatically — health checks, log analysis, disk space monitoring, backup verification. Things I used to do manually (or, more honestly, things I used to forget to do manually).

# Hermes cron configuration (excerpt)
cron:
  - name: "cluster-health-check"
    schedule: "*/30 * * * *"  # every 30 minutes
    task: "Check all Proxmox nodes. Report any node with CPU > 85%,
           memory > 90%, or any service in a failed state.
           Post summary to #sorren-ops."

  - name: "gpu-monitoring"
    schedule: "*/10 * * * *"
    task: "Check GPU temperatures and utilization across inference
           and training rigs. Alert if any GPU exceeds 85C or
           shows unexpected utilization."

  - name: "nightly-backup-verify"
    schedule: "0 2 * * *"
    task: "Verify last night's backups completed successfully.
           Check backup integrity. Report any anomalies."

Hermes runs these on schedule, uses its tools to actually check the systems (not just generate plausible-looking text), and posts results to the Discord channel. If something is wrong, it flags it. If something needs my attention, I get a ping.

The first time it caught a failing disk before SMART warnings triggered, I was sold.

Delegating Parallel Work

The feature I've been exploring most recently is delegate_task — the ability to spawn subagents for parallel work. When I need to do three independent things (say, update the inference server config, audit the vector database indexes, and write a new monitoring dashboard), Hermes can delegate each to a separate subagent and run them concurrently.

Me: "Update the vLLM config for the new DeepSeek model,
     audit Qdrant index sizes, and build a Grafana panel
     for adapter swap latency."

Hermes: spawns 3 subagents
  - subagent 1: reads current config, updates model paths, tests
  - subagent 2: queries Qdrant, reports index sizes and growth
  - subagent 3: builds the dashboard, tests the queries, deploys

What used to be three sequential tasks is now three parallel ones. The wall-clock savings add up.

Hermes vs. OpenClaw

I adopted OpenClaw last year for automated infrastructure tasks. It's good — reliable, scriptable, handles batch operations well. But OpenClaw is fundamentally a one-shot tool. You configure a task, it executes, it's done.

Hermes is persistent. It has memory across sessions. It learns my infrastructure layout, my preferences, my conventions. When I tell it "restart the inference server," it knows which server, which container, what the restart procedure is, and what to check afterward. I didn't have to script that. It learned it.

OpenClaw still has its place for deterministic, repeatable batch operations. Hermes is for everything else — the exploratory, the adaptive, the "figure it out and tell me what you found" work.

What This Actually Changes

The practical impact is this: I spend less time on mechanical infrastructure work and more time on architecture. The repetitive checks, the routine maintenance, the "is this thing still running" questions — Hermes handles those. I handle the decisions that actually need a human.

Whether that makes me more productive or just gives me more time to find new problems to solve is an open question. It's almost midnight. I'm going to stop examining it and go to sleep.

Hermes will wake me if anything breaks.