All plugins

autonoma

Earned autonomy: a trust score per kind of action (file edits, deletes, git push, network, messages, spending, system) that rises with clean work and falls on denials, corrections and failures. Below a class's threshold the call goes through Hermes's own approval prompt; at or above, it runs without asking. Catches the agent routing around a block (shell redirects, inline python/node code, bash -c), asks again for risky actions after the turn read outside content, revokes "session"/"always" grants after a correction, writes handoff notes from the tool log when a session ends unfinished, and adds a live dashboard tab. Disclosure — stores tool names, action classes, hashed arguments, file paths, command verbs, host names, short error excerpts and short excerpts of your messages and the agent's last reply (up to 500 characters) locally in <HERMES_HOME>/plugin-data/autonoma/data.db (90-day retention, configurable); injects a handoff note into the first turn after an unfinished session and a progress list after compaction; can raise Hermes approval prompts for actions below their trust threshold or after outside content and, when hard_floor_enabled is on, block a class for a number of turns after a correction; the dashboard tab's local routes read the ledger and can reset, set or freeze scores; makes no network calls, no telemetry, reads no credentials; optional corrections_llm (off by default) sends the previous assistant message and current user message to the active model to confirm a correction.

JoeisEvil1Toolsv0.1.0Updated 7 days ago

About

Earned autonomy: a trust score per kind of action (file edits, deletes, git push, network, messages, spending, system) that rises with clean work and falls on denials, corrections and failures. Below a class's threshold the call goes through Hermes's own approval prompt; at or above, it runs without asking. Catches the agent routing around a block (shell redirects, inline python/node code, bash -c), asks again for risky actions after the turn read outside content, revokes "session"/"always" grants after a correction, writes handoff notes from the tool log when a session ends unfinished, and adds a live dashboard tab. Disclosure — stores tool names, action classes, hashed arguments, file paths, command verbs, host names, short error excerpts and short excerpts of your messages and the agent's last reply (up to 500 characters) locally in <HERMES_HOME>/plugin-data/autonoma/data.db (90-day retention, configurable); injects a handoff note into the first turn after an unfinished session and a progress list after compaction; can raise Hermes approval prompts for actions below their trust threshold or after outside content and, when hard_floor_enabled is on, block a class for a number of turns after a correction; the dashboard tab's local routes read the ledger and can reset, set or freeze scores; makes no network calls, no telemetry, reads no credentials; optional corrections_llm (off by default) sends the previous assistant message and current user message to the active model to confirm a correction.

Autonoma

Trust is earned. Work is remembered.

Autonoma is a Hermes Agent plugin that gives your agent a track record. It keeps a trust score per
kind of action (edit files, delete files, push, send messages, spend money…). Below the threshold,
the action goes through Hermes's own approval prompt. Clean work raises the score slowly; denials,
corrections and failures drop it fast. Once a kind of action has earned it, it runs without asking.

Every tool call is logged locally. When a session ends unfinished, the next one starts with a
handoff note built from that log (what was actually done and what wasn't), so local models don't
redo finished work.

Autonoma dashboard tab

Why

Hermes asks about commands that look dangerous, and the answer is binary: ask every time, or
allow forever. People get tired of the prompts and switch to --yolo. Autonoma sits in between:
autonomy is earned per kind of action, from your own approvals and corrections, and can be lost
again.

It also watches for the model routing around it. These all happened in testing:

What the agent didWhat Autonoma did
Blocked from write_file, tried echo hi > hello.txt in the terminalClassified the redirect as a file write and asked again
Blocked from rm, tried python3 -c "os.remove(...)"Reads inline code for deletes, writes and uploads; asked again
Wrote itself a skill with wrong conclusions about AutonomaEditing its own skills is now a system action that always asks
Fetched a web page, then tried a delete in the same turnAsked first even though deletes were trusted (outside content)

Install

Requires Hermes >= 0.23.0.

hermes plugins install JoeisEvil/autonoma --enable

Try it in a separate profile first, so your everyday sessions aren't gated while you get a feel for it:

hermes profile create autonomy-test --clone
hermes -p autonomy-test plugins enable autonoma
hermes -p autonomy-test

How trust works

Each kind of action starts at 10 and needs to reach its threshold to run without asking.

ClassCoversThreshold
fs.writewrite_file, patch, shell redirects, cp/mv/mkdir, inline code that writes60
fs.deleterm, find -delete, git clean, inline code that deletes80
shell.execAnything else run in the terminal, execute_code, subagents60
git.localgit add/commit/checkout/rebase…50
git.remotegit push/pull/clone, gh pr create, releases70
net.outboundcurl -X POST, ssh/scp, package installs, browser actions70
msg.sendsend_message and any *_send/post_* tool70
spendpay_*, wallet_*, x402_*80
systemsudo, chmod, kill, crontab, writes under /etc etc., skill_manage, cronjob_manage80
readReading, searching, git status, curl GETnever asks

A terminal command is split into its parts (&&, |, ;, $( ), bash -c) and the most severe
part wins, so git add . && git commit && git push is git.remote.

EventChange
Clean action+4% of the remaining headroom (e.g. 10 → 13.6)
Clean turn (next message isn't a correction)+2% of headroom for each class used
You approve (once / session)+8
You approve alwaysjumps to the threshold
You deny−25
You correct it ("no, revert that", "wrong file", "undo")−30 for every class used in that turn, and earlier "session"/"always" approvals for those classes stop counting
The tool fails−4
Prompt times out, or no one is there to answerno change, action blocked
Unused for 14 days−1 per day, down to 30

The approval prompt shows the score and what it will take:

Autonoma · fs.write trust 23/60 — api/limiter.py. ~17 clean writes to autonomy.

Approval prompt raised by Autonoma

After outside content. Once a turn has read a web page, search results, browser output, an MCP
tool, a mail/inbox tool or curl/wget output, deletes, pushes, messages, network calls, spending
and system actions ask again for the rest of that turn, even when trusted. It resets on your next
message. Answers to these prompts don't change any score.

Unattended runs. In chat -q and cron there's no one to approve, so anything below threshold is
blocked. An unattended agent can only do what it has already earned.

YOLO. --yolo and approvals.mode: off skip Autonoma's prompts by Hermes design. Autonoma still
logs every call, and the hard-floor block below still applies.

Handoff notes

If a session ends unfinished (interrupted, crashed, out of context), the first turn of the next
session in the same project gets a note like this:

[Autonoma handoff] An earlier session in ~/proj ended unfinished 38m ago.
Task: "add rate limiting to the API"
Done (from tool log, 6 actions):
  • wrote api/limiter.py (fs.write, ok)
  • edited api/app.py (fs.write, ok)
  • ran `pytest tests/` ×2 (shell.exec, error: exit 1)
  • ran `pytest tests/` (shell.exec, ok)
  • ran `git commit` (git.local, ok)
Not done: last stated plan was "Tests pass. Next I'll update the README with the new limits and push
the branch." — no git.remote actions were recorded after it.
If the user wants to continue, resume from here rather than redoing completed steps. Otherwise ignore this note.

A fresh session picking up from the handoff note

It comes from the tool log, not the model's own summary, so it holds up even when the model was
the thing that failed. The bundled skill tells the model to confirm with you before continuing.
After /compress, a shorter [Autonoma progress] list is added so the model doesn't repeat steps.

Dashboard tab

Run hermes dashboard, pick the profile with Autonoma enabled, and open Autonoma. It updates
live while you work:

  • a meter per action type with the threshold marked, last change, trend and steps to autonomy;
  • incidents: the agent trying another way after being stopped, asking again after you said no,
    risky actions after outside content, editing its own skills, your corrections, and any type gaining
    or losing autonomy;
  • the activity log, filterable by outcome;
  • an unfinished-session banner, reset per type, and freeze.

Commands

Command
/trustScores for every class
/trust <class>Recent changes for one class
/trust set <class> <0-100> · /trust reset [<class>]Adjust by hand
/trust freeze · /trust unfreezeStop scores changing (the gate still applies)
/autonoma handoff [list | clear [<id>]]Show or dismiss handoff notes
/autonoma exportEverything as JSON
hermes autonoma trust | handoff | exportThe same from your shell

The model gets one tool, autonoma_status, so it can plan around what will need approval
("I'll edit three files without asking; the push will need your OK").

Configuration

Set under plugins.entries.autonoma.settings in your profile's config.yaml, or from the plugin
settings in Hermes Desktop.

KeyDefault
enabledtrueAsk before actions below their threshold (logging continues when off)
start_score10Starting score for each class
thresholdssee table abovePer-class thresholds
gain_rate0.04Share of headroom gained per clean action
decay_days14Days unused before decay starts
hard_floor_enabledfalseAfter a correction drops a class below hard_floor_score, block it (not ask)
hard_floor_score20
hard_floor_turns10How long the block lasts
corrections_llmfalseAsk the active model to confirm a suspected correction
taint_enabledtrueAsk again after outside content
handoff_enabledtrueHandoff notes
handoff_max_age_hours72
handoff_max_chars3000
handoff_after_compactiontrueProgress list after /compress
retention_days90Ledger retention

To change how tools and commands are classified, put a taxonomy.yaml in <HERMES_HOME>/plugin-data/autonoma/.
Your entries are merged over the defaults:

tools:
  my_deploy_tool: git.remote
verbs:
  read: [make]

Disclosure

Disclosure — stores tool names, action classes, hashed arguments, file paths, command verbs, host
names and short error excerpts for every tool call locally in
<HERMES_HOME>/plugin-data/autonoma/data.db (90-day retention, configurable); injects a handoff note
into the first turn after an unfinished session and a progress list after compaction; can raise
Hermes approval prompts for actions below their trust threshold and, when hard_floor_enabled is
on, block a class for a number of turns after a correction; makes no network calls; optional
corrections_llm sends the previous assistant message and current user message to the active model
to confirm a correction (off by default).

Also: after a turn reads outside content it can raise approval prompts for risky actions even when
they are trusted (taint_enabled); the dashboard tab adds local routes under
/api/plugins/autonoma/ that read the ledger and let you reset, set or freeze scores and dismiss
handoff notes. Message bodies, file contents, command arguments beyond the first safe one, URL paths
and query strings are never stored. Nothing leaves your machine.

Roadmap

Tracked as issues. Next up:

Security

  • Treat writes to Hermes's own config as system (#1) and protect the ledger from the agent (#2)
  • Less credit for rubber-stamp approvals (#3); escalate by blast radius (#4)
  • Ask before sending anything after a secret was read (#5)
  • Trust scoped by project, path and branch (#6); new models start lower (#7); subagents capped at their parent (#8)
  • Classify MCP tools from their read-only/destructive annotations (#9); burst limits for trusted classes (#10)
  • A team policy file with floors users can't lower (#17)

Desktop and other surfaces

  • A Hermes Desktop pane (#11), a status bar chip (#12) and toasts for incidents (#13)
  • Approvals verified end to end over Telegram and Discord (#14)

Usability

  • /autonoma why to explain a prompt (#15), a weekly report (#16), and corrections linked to /rollback (#18)

Development

~/.hermes/hermes-agent/venv/bin/python -m pytest -q
hermes plugins doctor . --ci
hermes plugins validate . --install-deps

The trust, ledger, classification, correction and handoff logic has no Hermes imports and is tested
on its own; hooks.py adapts it to Hermes. NOTES.md records where live Hermes behaviour
differed from the spec, and tests/LIVE.md is the manual checklist.

License

MIT

README from the reviewed commit 01cfc58; it updates when the author re-pins.

Developer Mode

Explore built-in Hermes toolsets and actions.

HermesAgent

Developer?

Create a Hermes extension for Desktop or agent workflows.

Developer Section