Skip to content
Back to search

hermes-multi-agent-workflow

A reusable skeleton for an autonomous, multi-agent triage pipeline built on Hermes: a fleet of agents that detects items from sources, dedups them, scores them against a rubric, researches them in…

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/tonbistudio--hermes-multi-agent-workflow/badge.svg)](/listings/tonbistudio--hermes-multi-agent-workflow)

HTML

<a href="/listings/tonbistudio--hermes-multi-agent-workflow"><img src="/api/listings/tonbistudio--hermes-multi-agent-workflow/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

pip install -r requirements.txt          # just PyYAML
python -m cli.triage validate            # check the example config
python -m unittest discover -s tests     # engine + board-client tests, no live Hermes needed
python -m cli.triage scaffold            # print the Hermes setup plan

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 115 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Hermes Multi-Agent Workflow
  2. A reusable skeleton for an **autonomous, multi-agent triage pipeline** built on
  3. [Hermes](https://github.com/NousResearch/hermes-agent): a fleet of agents that
  4. **detects** items from sources, **dedups** them, **scores** them against a rubric,
  5. **researches** them in parallel, **routes** each to a fulfillment path, pauses at
  6. **one human approval gate**, then **fulfills and delivers** — all coordinated on a
  7. single Hermes Kanban board.
  8. It ships pre-wired as a worked example (find pain points AI-agent users hit →
  9. build a fix or make an explainer video), so you can read a complete pipeline and
  10. then repoint it at your own domain.
  11. > **This is a template, not a turnkey app.** It runs its unit tests and validates
  12. > its config out of the box, but going live requires setting up your Hermes
  13. > install, profiles, auth, and scouts (see `docs/07-runbook.md`). The point is to
  14. > give you — and your coding agent — a clear, working structure to adapt.
  15. ## The idea
  16. ```
  17. sources → intake → dedup → score → research (parallel) → route
  18. │
  19. ┌──────────────────────┬──────────────────────┤
  20. path A path B shelve
  21. (prep) (prep) (auto)
  22. └──────────┬───────────┘
  23. ── HUMAN GATE ── approve · shelve · modify
  24. ┌──────────┴───────────┐
  25. fulfill fulfill
  26. └──────────┬───────────┘
  27. deliver
  28. ```
  29. The shape is fixed; **what flows through it is yours.** Everything domain-specific
  30. lives in one file, `triage.yaml`.
  31. ## Quickstart
  32. ```bash
  33. pip install -r requirements.txt # just PyYAML
  34. python -m cli.triage validate # check the example config
  35. python -m unittest discover -s tests # engine + board-client tests, no live Hermes needed
  36. python -m cli.triage scaffold # print the Hermes setup plan
  37. ```
  38. ## Adapt it to your domain
  39. The whole adaptation is editing `triage.yaml` + the markdown templates it points
  40. at. Hand your coding agent **`AGENTS.md`** and ask it to walk you through
  41. `docs/04-adapting-to-your-domain.md`. In brief:
  42. 1. Edit `triage.yaml`: sources, rubric, research lanes, route map, paths, roles.
  43. 2. Edit `paths/` templates (scope rails, deliverable specs, proposal formats).
  44. 3. Edit `skills/templates/` (scout queries + orchestrator notes).
  45. 4. `python -m cli.triage validate`, keep `tests/` green.
  46. 5. Follow `docs/07-runbook.md` to set up profiles and go live.
  47. ## Repository layout
  48. ```
  49. triage.yaml THE config — your whole pipeline (start here)
  50. AGENTS.md Guide for the AI agent adapting this template
  51. engine/ Generic engine (rarely edited)
  52. config.py Loads + validates triage.yaml
  53. engine.py TriageEngine — all deterministic step logic
  54. scoring.py Rubric scoring (LLM mode + deterministic mode)
  55. routing.py Classification → path
  56. dedup.py Similarity (token-cosine; embedding-ready)
  57. item_vault.py One markdown file per tracked item
  58. hermes_board.py Writes the Hermes Kanban board (via `hermes kanban`)
  59. intake_parser.py Parses scout reports
  60. frontmatter.py Stdlib YAML-frontmatter for item files
  61. proposal_actions.py Human-gate handler (approve/shelve/modify) — config-driven
  62. paths/ Per-path templates you customize
  63. rails/ specs/ proposals/
  64. skills/templates/ Scout + orchestrator SKILL.md templates
  65. cli/triage.py validate / scaffold / init / install
  66. scripts/cost_report.py Per-item spend for the cost gate
  67. tests/ Generic engine tests
  68. docs/ Deep-dive docs (architecture, board, config, adapting, …)
  69. examples/ Reference configs
  70. ```
  71. ## Documentation
  72. - `docs/01-architecture.md` — fat engine / thin skill; how the pieces fit.
  73. - `docs/02-the-board.md` — Kanban as the bus; dispatcher; fan-in.
  74. - `docs/03-config-reference.md` — every `triage.yaml` key.
  75. - `docs/04-adapting-to-your-domain.md` — the step-by-step adaptation guide.
  76. - `docs/05-pipeline-stages.md` — each stage, and the gotchas to preserve.
  77. - `docs/06-security.md` — trust surface, scope rails, safe publishing.
  78. - `docs/07-runbook.md` — profiles, board, crons, go-live.
  79. - `examples/ai-agent-pain-points/REFERENCE.md` — full write-up of the reference
  80. implementation this template was extracted from.
  81. ## Security
  82. This template runs LLM-authored code and shells out, behind one human gate. Read
  83. **`SECURITY.md`** and `docs/06-security.md` before deploying — and run the
  84. pre-publish secret-scan checklist before open-sourcing an adapted copy.
  85. ## Contributing
  86. See **`CONTRIBUTING.md`**. The golden rule: keep `engine/` domain-agnostic; new
  87. domains go in `triage.yaml`, not the code.
  88. ## License
  89. MIT — see `LICENSE`.
  90. ## Credits
  91. Extracted and generalized from a working single-machine Hermes pipeline. The
  92. engine is domain-agnostic; the bundled example reflects its origin.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.