Post

Hermes Agents: The Current Roster, What Each One Watches and Which Ones Use a Model

Hermes Agents: The Current Roster, What Each One Watches and Which Ones Use a Model

This is the index for a series on the agents that run automated operations inside this homelab. The first post covered the agent itself: its guardrails, identities, and how access works. This one lists the whole crew: what each agent watches, when it runs, where its output goes, and whether it uses a model. Ten of them are Hermes cron jobs, and all ten are plain scripts with no model. The model only shows up in the docs pipeline.

Purpose

Instead of one general-purpose agent doing everything, each task runs under a tight identity with only the permissions it needs. The scanner can read the cluster but write only its own results; the docs worker can open a pull request but never merge it; the compliance checks report findings. The design keeps the language model away from anything that writes state: write access goes through gate tools that validate inputs, run linting and security scans, and produce artifacts (issues or pull requests) a human reviews.

The design rules are the same for every agent: a deterministic collector, a model only where prose is needed, report instead of act, one read-only identity per agent, and LLM work only through the docs queue.

Architecture

The system has three layers: facts, agents, and gates.

Facts. Hosts push their own state to JSON files (timezone, log drivers, ports, mounts, networks). The k3s cluster doesn’t push anything: the agents read it through a read-only identity.

Agents. Ten run as Hermes cron jobs, in the first group of the table. The second group runs through the docs queue. Each one reads facts, applies rules, and produces output:

AgentScheduleOutputModel
Kubescape scan + triagedaily 05:10Scan results and baseline comparison fed to the ops digestNone
Config compliancedaily 05:20Four rolling issues (timezone, logging, provenance, repo inventory)None
Ops digestdaily 05:30Rolling issue updated only when findings changeNone
Article suggestdaily 06:30Rolling suggestions issue, plus docs-idea issues on the doc-site repoNone
ZFS healthdaily 06:45Rolling “ZFS health” issue; email when a critical finding is newNone
Web UI authdaily 06:50Rolling “Web UI authentication” issueNone
DR auditdaily 06:55Rolling “DR readiness” issue; email when a critical gap is newNone
Health boarddaily 07:00One findings list built from every agent’s reportNone
Docs drift detectorweekly Sunday 03:00Rolling issue listing stale facts in postsNone
Docs queue syncevery 15 minutesKanban board populated from briefs, one “brief” card per ideaNone
Brief writerper docs-idea issue, via the docs queueOne brief comment on the idea; I approve it with the docs-request labelClaude Sonnet 5.5
Doc writer (draft, check and publish cards)per approved briefA pull request for reviewClaude Sonnet 5.5
Docs fact-checkerbetween draft and publishPass or findings on the draftClaude Sonnet 5.5
Agent and model usage reportdailyDaily rolling issue and a Grafana dashboardNone

What each one does:

  • Kubescape scan + triage scans with a read-only identity and compares the result with a 7-day rolling baseline.
  • ZFS health reads pool, scrub, capacity and replication state pushed by the ZFS hosts. The rolling issue has a pool table per host and a replication table.
  • DR audit checks backup freshness against recovery-point targets per tier: guest backups, cluster state, host config, k3s persistent volumes (ZFS replication of the local-zfs volumes) and local ZFS tasks. It also flags restore tests older than 90 days.
  • Web UI auth inventories every web route (k3s ingress routes and Docker-host router labels) and matches each one to a catalog entry. It makes unauthenticated GET probes only, to see whether authentication is on and which kinds the app supports. It feeds the health board as a security source.
  • Health board consolidates the reports into one findings list with a shared contract: stable id, report, source, type and severity. The first live data was 74 findings.
  • Article suggest files docs-idea issues with a hidden id marker. Each run passes the sanitize and gitleaks checks.
  • Brief writer is a skill run by a docs worker. It turns a docs-idea issue into a brief and posts it as one comment.
  • Docs fact-checker is a check card between the draft and publish steps, run in a fresh session with the fact-checker skill. It compares every claim with the brief, the cited records and the facts file. publish-post refuses unless that exact file passed. On findings there is one automatic re-draft, then it goes to me. It exists because a draft once said 12 TB where the brief said 13.5 TB and all five automatic checks still passed.
  • Agent and model usage report counts runs per agent, whether a model was used, which one, local GPU or cloud, and the estimated cost.

Gates. Two tools handle publishing. report-issue updates a rolling Gitea issue in place: it reads the report, validates file ownership and size, runs gitleaks (plus sanitize-check for public repos), then creates or updates the issue. publish-post does the same for documentation posts, pushing to a fork and opening or updating a PR. Both are sudo-gated: each cron job’s identity can call exactly one wrapper binary.

The scheduled agents and the gates:

flowchart LR
    F["Facts files"]
    KK["kubectl (read-only identity)"]
    AG["Scheduled agents<br/>ops digest, compliance, kubescape,<br/>ZFS, DR, web auth, article suggest, drift"]
    HB["Health board 07:00"]
    RI["report-issue"]
    ISS[("Rolling issues (private repo)")]

    F --> AG
    KK --> AG
    AG --> RI
    RI --> ISS
    ISS --> HB
    HB --> RI

The docs pipeline and the usage report:

flowchart LR
    QS["Queue sync (every 15 min)"]
    BW["Brief writer (model)"]
    DW["Doc writer (model)"]
    FC["Fact-checker (model)"]
    PP["publish-post"]
    PR[("Pull request (owner reviews and merges)")]
    US["Agent usage report"]
    GF["Grafana dashboard and daily issue"]

    QS --> BW
    BW --> DW
    DW --> FC
    FC --> PP
    PP --> PR
    US --> GF

Permissions and roles

Every agent runs under its own identity. There is no master account:

  • Gitea (read): a restricted bot account with read-only scopes for repos, issues, PRs, and CI runs. The scanner’s write identity lives in a separate token under a different user.
  • Publish: two system users hold the write tokens. Each has exactly one sudo rule allowing a single wrapper. The wrappers validate arguments (allowlisted report names and file paths), check file ownership, enforce no-symlink reads, run gitleaks, and push output as an issue body or PR commit.
flowchart LR
    MODEL["Claude Sonnet 5.5 (cloud)"]
    AGENT["Docs-queue card session"]
    CRON["Cron job (plain script, no model)"]
    W1["report-issue wrapper"]
    W2["publish-post wrapper"]
    ID["Separate identities per task"]

    MODEL -->|"prompt + tool call"| AGENT
    AGENT -.->|"sudo (one binary)"| W2
    CRON -.->|"sudo (one binary)"| W1
    W1 --> ID
    W2 --> ID

How it runs

Hermes cron jobs handle scheduling. They run in “no-agent” mode: a plain script executes, outputs results, and that output is delivered, with no LLM turn at all. Jobs run daily with order enforced by offset:

  1. 05:10: the Kubescape scan runs with a read-only identity
  2. 05:20: config compliance runs against fresh facts
  3. 05:30: ops digest collects from its sources, applies rule-based thresholds, and includes the kubescape triage against a 7-day rolling baseline
  4. 06:30 to 06:55: article suggest, then ZFS health, web UI auth and DR audit
  5. 07:00: the health board reads the other agents’ reports

The docs queue sync runs every 15 minutes, and the docs drift detector runs on Sundays at 03:00.

The model is only involved where prose matters: briefs from short ideas, post drafts, and the fact check that compares a draft with its sources. Those cards run on Claude Sonnet 5.5, and every docs-queue card starts that way. The collectors, the rules and the reports are plain scripts. Even for posts, the publishing step is a deterministic tool call with its own validation. For a comparison of a local model and Sonnet on the doc agent, see the Qwen vs Sonnet post; for how the agents are graded, see Grading the agents.

The usage report shows how little model use there is. In its dry run on 2026-11-02, the only model use was the docs worker on Sonnet 5.5 in the cloud: 29 sessions, about $4.46 estimated over 7 days. The local GPU (Ollama) handled 1,496 requests over the same 7 days, for knowledge-base embeddings and a laptop client. Hermes’s own cost field reads $0 because its price list lacks the model, so the report computes cost from tokens times configured prices.

How it relates to the other agents

The data flows one direction: hosts push facts, collectors read, agents report. The health board sits at the end and reads what the others wrote. There are no circular dependencies between jobs except where that is intentional: the docs pipeline fixes drift findings, and the ops digest watches all of them (did the kubescape job run on time, is any kanban card stale). The pattern is the same: find something, describe it, hand it off. No agent trusts another’s output at runtime because there’s no runtime consumer: every consumer is a human reading an issue or reviewing a PR.

The series

Each agent gets its own post covering the collectors it uses, the rules it applies, false-positive handling, and what happens when things go wrong:

Notes

The trade-off is speed for safety. A finding discovered at 05:30 does not get fixed automatically: it sits in a rolling issue until I review it, decide on a fix, or acknowledge why it’s expected (acknowledgments are time-boxed; an expired one re-becomes a finding). In exchange, nothing runs with more permissions than it needs to complete its job, no secrets can escape the wrappers, and every write is a visible artifact that survives beyond a single session.

This post is licensed under CC BY 4.0 by the author.