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:
| Agent | Schedule | Output | Model |
|---|---|---|---|
| Kubescape scan + triage | daily 05:10 | Scan results and baseline comparison fed to the ops digest | None |
| Config compliance | daily 05:20 | Four rolling issues (timezone, logging, provenance, repo inventory) | None |
| Ops digest | daily 05:30 | Rolling issue updated only when findings change | None |
| Article suggest | daily 06:30 | Rolling suggestions issue, plus docs-idea issues on the doc-site repo | None |
| ZFS health | daily 06:45 | Rolling “ZFS health” issue; email when a critical finding is new | None |
| Web UI auth | daily 06:50 | Rolling “Web UI authentication” issue | None |
| DR audit | daily 06:55 | Rolling “DR readiness” issue; email when a critical gap is new | None |
| Health board | daily 07:00 | One findings list built from every agent’s report | None |
| Docs drift detector | weekly Sunday 03:00 | Rolling issue listing stale facts in posts | None |
| Docs queue sync | every 15 minutes | Kanban board populated from briefs, one “brief” card per idea | None |
| Brief writer | per docs-idea issue, via the docs queue | One brief comment on the idea; I approve it with the docs-request label | Claude Sonnet 5.5 |
| Doc writer (draft, check and publish cards) | per approved brief | A pull request for review | Claude Sonnet 5.5 |
| Docs fact-checker | between draft and publish | Pass or findings on the draft | Claude Sonnet 5.5 |
| Agent and model usage report | daily | Daily rolling issue and a Grafana dashboard | None |
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-ideaissues 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-ideaissue 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-checkerskill. It compares every claim with the brief, the cited records and the facts file.publish-postrefuses 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:
- 05:10: the Kubescape scan runs with a read-only identity
- 05:20: config compliance runs against fresh facts
- 05:30: ops digest collects from its sources, applies rule-based thresholds, and includes the kubescape triage against a 7-day rolling baseline
- 06:30 to 06:55: article suggest, then ZFS health, web UI auth and DR audit
- 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:
- The ops digest, with log triage and the edge watch
- Kubescape scanning and baseline triage
- The docs pipeline, from a short idea to a reviewed PR
- The docs drift detector
- Config compliance: timezones, logging, provenance and the repo inventory
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.