Argus (Hermes plugin)
Argus reads a Hermes agent by intents instead of sessions and lets a person decide what to keep
of what it learns. It groups the agent's turns into intents (one goal, possibly over many turns,
sessions and days), shows which skills each intent read and taught, flags skill edits Hermes applied
without evidence and proposes edits of its own. A person keeps or rejects each edit and accepts or
dismisses each proposal; nothing changes a skill without that.

What an intent is, how Hermes learns and what Argus checks of it: the
repository README ("Intents", "Learning") and a
walkthrough from a flagged skill to an approved rule; storage: docs/data-model.md.
Install
Cost: derive can be expensive. It makes one model call per session with new turns and per
skill edit Hermes applied, then judges the intents those turns land in and, for an intent with 3
or more sessions, each of its runs, on theauxiliary.argusslot (unset: the curator's model).
On one busy personal agent (856 skill edits a week) a first derive over 2 days of history made
238 calls; 7 days would have been about 750 (635 edits to review), 20 days about 2,500 (291
sessions, 2,166 ledger entries). Start with--since 2to--since 7on a busy agent: backfill
andhermes argus statusprint the calls the next derive makes before it runs, the part known
now and an upper bound, and a later--sincewidens the window. The window never narrows, so a
too-wide first backfill commits that profile to its cost (without--since, the first backfill
takessince_days, 30).
Needs Hermes 0.22.5 or newer, on Linux or macOS (derive and apply lock with flock; native Windows
is not supported). Install it as the user Hermes runs as, from its repository, or from the plugin
catalog once it is listed there:
hermes plugins install albertodvp/argus#argus # or, once in the catalog: hermes plugins install argus
Or copy this directory to $HERMES_HOME/plugins/argus/ (default ~/.hermes) and enable it. Then:
hermes plugins enable argus # Nix-installed Hermes: add argus to plugins.enabled in config.yaml instead
hermes argus backfill --since 3 # sets the active profile's history window, read-only; prints the next derive's calls
hermes argus derive # model passes on the `auxiliary.argus` slot (`hermes model`)
hermes argus status # rows per profile, last backfill and derive, history window, next derive's calls
hermes argus export --out data.js
hermes argus apply --proposal <id> [--dry-run] # carry out an accepted proposal (or --rollback <entry>)
-p <profile> selects the profile, --all runs backfill/derive on every profile of the install.
In the agent, /argus shows the intent of the current session and what waits for review; on a
messaging platform, where anyone allowed in the chat can ask, it shows only the session's intents,
without the judge's advice or the profile's counts. A running dashboard shows the tab after
Plugins → Rescan dashboard extensions. After updating Argus, restart hermes dashboard: until then
its Argus API answers 503 instead of mixing the two versions. hermes plugins remove argus keeps
each profile's plugin-data/argus/; delete those directories to drop the data too.
History window: a profile's first backfill sets it (meta window_start) to --since DAYS, or to
the last since_days days (setting, default 30). A later --since widens it and reads the older
sessions (--since 0: the whole history); a narrower one is reported, never applied. Derive, export
and the status counts read only sessions with a message in the window. Derive skips a profile never
backfilled (idle trigger and dashboard refresh included); on the others it first catches up with
the tool outcomes and ledger entries since the last backfill, which keeps profiles without the
plugin (no hooks there) current. Skills are found where Hermes finds them: the profile's skills/,
then skills.create_dir and skills.external_dirs, as Hermes' skill_search_dirs lists them for
that profile (trusted project skill dirs, which Hermes lists before skills/, left out). When the
profile has no skills/ directory but Hermes lists other roots, nothing marks where those end, so
Argus reads no other skill directory and apply refuses. Two limits come from Hermes: a trusted
project's skill dir that the profile also lists in external_dirs or create_dir is left out
while Argus runs inside that project, and an external dir created after the first lookup is seen
only once config.yaml changes. A Hermes run in a
container or behind a wrapper needs that instance's own CLI in place of hermes.
What Argus does on your machine
What a user should know before installing (catalog rule 13):
- Model calls.
hermes argus derive(by hand, from the idle trigger or from the dashboard's
refresh) calls the model of theauxiliary.argusslot throughctx.llm; unset, the curator's
model. Its prompts carry text of the agent's turns: user messages and replies, the start of each
tool call's arguments (120 characters) and of each tool result (220 characters), and tool error
lines; these can hold commands, paths or other values the agent used. They also carry skill
diffs from the curator ledger and, for a proposal, the current
SKILL.mdof that skill. One pass uses one slot for every profile it derives: with--alland
from the dashboard's refresh, the turns of every backfilled profile go to theauxiliary.argus
model of the profile that runs the pass. How many calls: Install; backfill and
statusprint the next pass's count. After 5 model errors in a row (provider down, quota) the
pass stops and exits non-zero. Argus makes no other network request and sends no telemetry. - Reads outside its own data, read-only. Each profile's
state.db, the curator ledger
skills/.curator_ledger.jsonland its blob store.curator_backups/blobs/, theSKILL.mdfiles
of the skill directories Hermes'skill_search_dirslists for it (skills/,skills.create_dir,
skills.external_dirs; Argus does not parseconfig.yamlitself, Hermes reads the profile's
configuration to answer) and staged writes underpending/skills/. With--all, and always in the dashboard,
that is every profile of the install, including profiles that do not enable Argus. The dashboard
tells whether a derive pass is running from the profiles'derive.lock, and whether Argus changed
on disk from the files of its own directory. - Writes.
plugin-data/argus/in each profile it reads (SQLite database, run reports, logs,
locks). Skills and the ledger change only on an apply (below). - Background processes. After a turn, when the agent has been idle
idle_minutesand no pass
ran forinterval_minutes, Argus starts a detachedhermes -p <profile> argus derive --quiet, one
at a time (derive.lock); the dashboard's refresh startshermes argus derive --all --quietthe
same way. Each exits when its pass ends. Nothing in them waits for a person, so they are safe
under cron and the gateway. The dashboard's apply button runsapply_child.pywith the install's
Python andHERMES_HOMEset to the decision's profile, stopped after 45 seconds. These are the
only processes Argus starts, each from an argument list, never through a shell. - Skill writes. Only after a person decides and then clicks apply (the confirmation shows the
lines it inserts) or runshermes argus apply. A rejected edit is undone with Hermes'
rollback_entry, the same restore ashermes curator rollback, refused when the file changed
after that entry (Hermes refuses one outside the profile's home, e.g. inskills.external_dirs).
An accepted proposal goes throughskill_manage(action="patch"), which refuses a
locked skill and, withskills.write_approvalon, only stages the write for/skills approve;
apply refuses it when its rule or diff changed after the person accepted it, when Hermes now
resolves the skill to another file than the proposal was derived from, and when the skill's
SKILL.mdor directory is not writable here (a sharedskills.external_dirsis often read-only:
the dashboard marks those proposals read-only, to carry to wherever that skill is maintained).
skill_managetakes only a name and finds the file itself, so apply writes only where that
name can lead to the file it checked: aSKILL.mdin the profile'sskills/, reached without a
symlink, outside the directories Hermes may not scan, and the only directory with the skill's
name in Hermes' skill roots (Argus keys a skill by that name); a skill in a category is named by
its path (<category>/<skill>). Anything else is refused. After a
patch, a new ledger entry must name the file apply checked; otherwise the outcome isunknown
(also withskills.ledgeroff), with the entry id when there is one. Ledger actor:user. The
dashboard's copy buttons give terminal commands with every value shell-quoted. - Credentials. Argus reads, stores and requests none. (Hermes reads the profile's configuration
when Argus asks it for the skill directories; Argus gets back paths only.)
What runs where
| Module | Role |
|---|---|
capture.py | hooks (pre_llm_call, post_tool_call, on_session_end, on_skill_lifecycle, on_session_delete); enqueue rows only, never call a model |
backfill.py | tool_outcome from state.db tool messages, skill_edit from the curator ledger; idempotent, cursor in meta; sets and widens the history window (window_start in meta) |
derive.py | intents, runs, edit reviews, proposals |
hermes_data.py | read-only state.db / ledger / blob access, column check |
store.py | <home>/plugin-data/argus/data.db (schema schema.sql), write queue |
apply.py | hermes argus apply and the dashboard's apply button: rollback_entry / skill_manage patch or create (new skill) as ledger actor user, checks first (current decision, no later change, context unchanged, rule not yet present), one row per attempt in apply_log |
apply_child.py | the dashboard's apply process: apply.run with HERMES_HOME = the decision's profile, so it works in profiles that do not enable the plugin |
After a turn, when the agent has been idle idle_minutes (default 10) and no pass ran for
interval_minutes (default 60), a detached hermes argus derive --quiet starts (one at a time,
plugin-data/argus/derive.lock, output in derive.log). Settings live under
plugins.entries.argus.settings.
Argus never writes state.db or the ledger itself; hermes argus apply changes a skill, and so the
ledger, only through Hermes' skill_manage / rollback_entry.
README from the reviewed commit cca0fbc; it updates when the author re-pins.

albertodvp