All plugins

git-review

Git review pane for Hermes Desktop: every changed file of the agent's last turn, uncommitted, staged or unstaged work, the branch since it left the default branch, or any selection of commits, in one scroll, unified or split, with syntax colours; cites changed lines into the composer as @line: references; and stages, unstages, discards, commits, pushes and opens pull requests from the pane. Disclosure — reads run git subprocesses (rev-parse, status, diff, log, show, cat-file, ls-files, for-each-ref, branch, remote, rev-list, merge-base, symbolic-ref, hash-object) with timeouts and output caps, external diff and textconv drivers disabled. Writes run only when the user clicks: git add, restore, reset, rm, commit and push, on paths validated inside the repository; discard asks first in Desktop's confirmation dialog and deletes only the untracked files it names. By default hooks are skipped and any write that would run a program named by the repository's own config (filter drivers, signing, SSH or credential commands) is refused; the run_repo_programs setting allows them, and the read_only setting hides and refuses every write. Network use: push to the branch's own name on its remote, and the user's own gh or glab CLI for the PR/MR badge and for Create pull request; the plugin itself makes no network requests. Generate commit message sends what the commit will contain and recent commit subjects to the focused chat's model through Hermes's commit_message one-shot template, only when clicked. It reads files and history inside authorized repositories only (the focused workspace, configured repos/roots and the latest agent selection), this profile's config.yaml, and the cwd column of the sessions table in state.db (read-only); it writes $HERMES_HOME/plugin-data/git-review/select.sqlite3 (agent selection requests), $HERMES_HOME/plugin-data/git-review/turn-snapshots/ (Last agent turn snapshots: the working tree's tracked and non-ignored untracked files as git objects, written with git add -A and write-tree against a throwaway index and an object store in that directory, never the repository's; newest 16 kept, three days max), Desktop plugin storage (display settings, turn baselines) and, through the actions above, the user's repository. While the pane is open it polls the local backend every 3 s (agent selections) and 5 s (live diffs); the status-bar count and the commit box's branch state refresh every 15 s; no background processes, credentials or telemetry.

mister-ideas3Desktopv0.3.0Updated 14 days ago

About

Git review pane for Hermes Desktop: every changed file of the agent's last turn, uncommitted, staged or unstaged work, the branch since it left the default branch, or any selection of commits, in one scroll, unified or split, with syntax colours; cites changed lines into the composer as @line: references; and stages, unstages, discards, commits, pushes and opens pull requests from the pane. Disclosure — reads run git subprocesses (rev-parse, status, diff, log, show, cat-file, ls-files, for-each-ref, branch, remote, rev-list, merge-base, symbolic-ref, hash-object) with timeouts and output caps, external diff and textconv drivers disabled. Writes run only when the user clicks: git add, restore, reset, rm, commit and push, on paths validated inside the repository; discard asks first in Desktop's confirmation dialog and deletes only the untracked files it names. By default hooks are skipped and any write that would run a program named by the repository's own config (filter drivers, signing, SSH or credential commands) is refused; the run_repo_programs setting allows them, and the read_only setting hides and refuses every write. Network use: push to the branch's own name on its remote, and the user's own gh or glab CLI for the PR/MR badge and for Create pull request; the plugin itself makes no network requests. Generate commit message sends what the commit will contain and recent commit subjects to the focused chat's model through Hermes's commit_message one-shot template, only when clicked. It reads files and history inside authorized repositories only (the focused workspace, configured repos/roots and the latest agent selection), this profile's config.yaml, and the cwd column of the sessions table in state.db (read-only); it writes $HERMES_HOME/plugin-data/git-review/select.sqlite3 (agent selection requests), $HERMES_HOME/plugin-data/git-review/turn-snapshots/ (Last agent turn snapshots: the working tree's tracked and non-ignored untracked files as git objects, written with git add -A and write-tree against a throwaway index and an object store in that directory, never the repository's; newest 16 kept, three days max), Desktop plugin storage (display settings, turn baselines) and, through the actions above, the user's repository. While the pane is open it polls the local backend every 3 s (agent selections) and 5 s (live diffs); the status-bar count and the commit box's branch state refresh every 15 s; no background processes, credentials or telemetry.

git-review for Hermes Desktop

git-review: a marble Hermes holds up a diff tablet. A Git review pane for Hermes Desktop.

CI
Release
License: MIT

Review the whole change in one scroll, next to the chat. git-review is a review pane for Hermes Desktop. Every changed file is stacked in one continuous diff, so you read the agent's last turn, your uncommitted or staged work, the whole branch, or any range of commits the way you read a pull request, in unified or split layout, with syntax colours. Then it turns the lines you care about into @line: citations for your next message, and lets you stage, discard, commit, push and open the pull request without leaving the pane.

⌘⌥G opens git-review next to the chat; "Last agent turn" shows exactly what the turn changed; search looks inside the changes

Why it exists

An agent that edits code leaves you reviewing its work somewhere else. You switch to a terminal, rebuild what the turn touched, and lose the conversation around it. The last turn is the hardest case: part of it is committed and part is not, and no Git client groups it that way.

git-review keeps the review next to the chat and makes its result usable. Click a line, choose Cite in message, and the reference goes into your draft, so "this is wrong, here" costs a drag instead of a paragraph. Nothing is sent until you send it. When the change is right, stage it, commit it with a message Hermes drafts for you, and push, from the same pane.

See it work

Select the lines that are wrong and cite them back: the agent fixes just those.

Select two lines, cite them into the message, and the agent fixes just that

Ask Hermes to show you a change and it drives the pane. Then stage a file from its header, commit it with a generated message, commit and push the rest, and step through the branch one commit at a time.

The agent filters the pane to the README; stage, commit, commit and push; browse commit by commit

These clips are recorded in Hermes Desktop with the plugin as released.

Install

Requires Hermes Agent >=0.21.6 with Desktop, and git on your PATH.

hermes plugins install git-review

That installs the reviewed commit the Hermes plugin catalog pins. To track this repository instead, install it by URL: hermes plugins install mister-ideas/git-review.

Hermes asks whether to install Node dependencies, because the repository declares a package.json. Answer N. That file belongs to the test tooling, and the plugin needs nothing from npm at runtime.

Then:

  1. Enable git-review under Capabilities → Plugins, or run hermes plugins enable git-review. Desktop copies the pane from the package into $HERMES_HOME/desktop-plugins/git-review/ and loads it.
  2. Restart the backend, or quit and reopen Desktop, so the plugin's routes mount.
  3. Open the pane from the command palette (Toggle git review), with ⌘⌥G / Ctrl+Alt+G (rebindable under keyboard shortcuts), from the changed-files count in the status bar, or by toggling Git review in the right dock. Pressed again while the pane is on screen, the shortcut minimizes it and keeps its place and settings. This needs a Hermes Desktop with host.togglePane (NousResearch/hermes-agent#147157). On an older Desktop the shortcut only opens the pane, and the palette row reads Open git review.

Cloned it yourself? hermes plugins adopt git-review makes the directory a tracked install, so check-updates and update work on it.

To remove it: hermes plugins remove git-review.

Updating

hermes plugins check-updates          # read-only: is a newer version available?
hermes plugins update git-review

Restart the backend afterwards, then run Reload desktop plugins. If Desktop runs on a different machine from the backend, update the plugin on that machine too: the pane is copied from the package installed where the app runs.

What it shows

Six scopes cover the ways you review work. The first control in the toolbar picks one.

ScopeWhat it showsHow it is computed
Last agent turnEverything the agent changed in this repository during its latest turn: committed and uncommitted edits, terminal edits, new files.When you send a message, the plugin records a snapshot of the working tree, even while the pane is closed. The turn is the diff from that snapshot to the working tree now.
UncommittedAll work not yet committed: staged, unstaged and new files.The working-tree diff against HEAD, plus new files.
StagedOnly what is in the index.git diff --cached.
UnstagedWorking-tree edits not yet staged, and new files.git diff on the working tree, plus new files.
BranchThe net change of your branch since it left the default branch: what its pull request will show.git diff <merge-base> HEAD. The branch menu picks another branch to compare against.
CommitsThe commits your branch added since it left the base (origin/main, for example).Commit range since the merge base. Pick a subset, or browse one commit at a time.

Edits you left uncommitted before the turn are part of the snapshot, so they do not show as the agent's. An untracked file the agent edits shows only the agent's lines. When a snapshot cannot be recorded (untracked files above 64 MiB in total, or a snapshot already pruned), the turn falls back to comparing against the commit the turn started from, and earlier uncommitted edits then show too.

New files that are not staged yet appear in Uncommitted and Unstaged with their content. Turn Show new files off in the display menu to hide them.

The Branch scope: the branch's net change since it left main

Uncommitted work: a staged change and an unstaged change in one view

Commits

  • The list starts with every commit your branch added, all selected. Select all selects the whole list again after you have narrowed it, and Load older commits fetches more history, up to 250 commits per load.
  • Browse commit by commit steps through one commit at a time with the Newer and Older buttons. The navigator shows the commit, its subject, author, date and position, for example 4f16d57 · Document tax handling — mister-ideas, 10/23/2026 followed by 1/5. The position keeps its own place, so a long subject never hides it. All commits returns to the full selection.
  • The branch menu lists your local and remote branches. Pick one to show only the commits since it.
  • A shallow clone has only the history it fetched, and the pane says so. Plugin installs from Hermes are shallow. To see the full history, run git -C <plugin directory> fetch --unshallow.

Commit-by-commit browsing with the navigator

The Commits scope: five commits from one feature branch

Stage, discard, commit, push, pull request

In the Uncommitted, Staged and Unstaged scopes, each file header carries its actions, always on screen:

  • Stage and Unstage follow where the file's changes are. A file with changes on both sides offers both, and Uncommitted marks it partly staged.
  • Discard changes restores the file to HEAD, staged and unstaged edits included. On a new file it becomes Delete new file. Both ask first, in Desktop's own confirmation dialog. A renamed file gets both of its names back.
  • The same actions, plus Copy path and Reveal in file manager, are on the right-click menu of every file in the tree.

Discard asks first, in Desktop's confirmation dialog

Under the diff, the commit box:

  • Commit commits what is staged. With nothing staged it stages everything first, the way VS Code and Desktop's own Review pane do. ⌘/Ctrl+Enter commits.
  • The arrow next to it offers Commit & push, and makes either one the default.
  • Generate commit message drafts the message with Hermes's own commit_message template, on the focused chat's model, from exactly what the commit will contain and in the style of your recent subjects. Press again for a different draft, or to stop.
  • Push appears when the branch has commits to push, with their count. A branch without an upstream is published to origin.
  • Create pull request pushes and runs gh pr create --fill (or glab mr create --fill on GitLab), then opens the result. If the branch already has one, the button opens it.
  • Stage all, Unstage all, Discard all changes… and Ask Hermes to commit and open a PR are in the ⋯ menu. The last one puts the same request Desktop's own Review pane uses into the chat.

Stage, unstage and discard in every file header, a staged file, and the commit box

The Last agent turn, Branch and Commits scopes stay read-only: they describe history, not the index. To keep the whole pane read-only, turn on read_only in the settings.

Repository programs are off by default. A commit made here skips the repository's hooks, and a write is refused, with the reason, when the repository's own .git/config names a program git would run for it: a filter driver, a signing program, an SSH command or a credential helper. Turn on run_repo_programs to run git exactly as a terminal would. Your global and system git configuration, such as git-lfs or a credential manager, applies either way.

Layouts and colours

  • Unified stacks every changed file, with old and new line numbers in one column.
  • Split puts old and new side by side, with filler rows that keep the two sides aligned.
  • Narrow docks keep the toolbar on one line and give the width to the diff.
  • Syntax colours mark keywords, strings, numbers, calls, types and comments in about thirty languages (59 file extensions), with the theme's own hues. Each file header shows Desktop's icon for its type. Turn colours off in the display menu.

Split layout

Narrow dock

Folding and gaps

Unchanged runs are folded. Every change keeps three lines of context on each side, and the bar between changes says how many lines it hides, such as 29 unmodified lines. Expand a bar to reveal up to 20 lines at a time, or all of them. Runs above the first change and below the last fold too, so the end of a file is never a dead end.

Folding unchanged lines and expanding one run

Files

  • A file tree on the right shows each file's status and churn. Folders roll up their totals. Files: List in the display menu shows every file on one level, with its folder beside it.
  • Search covers file paths and the changed lines themselves. The tree keeps exactly the files the search found, so a match inside a file's changes lists that file even when its name does not match.
  • The Deleted files and Test files filters hide what you are not looking for.
  • Click a file to jump to its diff. Collapse one file, or use Collapse all and Expand all.
  • Review next file steps through the changed files in order.
  • Copy path copies the repository-relative path.
  • Drag a file from the tree into the composer to insert its absolute path.

Searching "feet" keeps the files whose changes mention it

Citing lines

Click a line, then another, and choose Cite in message. You can also press and drag across the gutter, or drag the selected lines straight into the composer. The pane writes a reference into the draft and never sends it:

@line:src/invoice/totals.ts:10-12

Lines are citable in every scope, so you can cite from the last turn, from the commits you are reviewing, or from your staged work.

A citation landing in the composer

The agent can drive the pane

The agent tool git_review_select points the pane at a repository and scope. For example, when you ask "show me what changed in the parser", the agent can open the right view for you. It takes repo, scope (uncommitted by default, or staged, unstaged, branch or commits), ref for specific commits, base for a range, path to filter to one file, and ignore_ws. The tool validates the request before the pane applies it. A request with path shows a File: README.md × chip in the toolbar; click it to see every file again. With several profiles on one gateway, the request reaches the pane of the profile you are chatting in.

Pull and merge requests

If gh (GitHub) or glab (GitLab) is installed and authenticated, and the checked-out branch has an open pull or merge request, the toolbar shows a button that opens it. The commit box creates one when there is none (see above); without the CLI, creating one reports that gh or glab is missing.

Always at hand

  • The status bar shows how many files changed in the focused workspace. Click it to open the pane.
  • Coming back to the Desktop window re-reads the changes at once, so edits made in an editor or a terminal show up without waiting for the next refresh.

Dark theme

The pane is painted only with Desktop's theme tokens, the same ones native panes use, so it follows light, dark and every skin (Catppuccin, Solarized, your own) with no colours of its own.

Dark theme

What the pane remembers

Display state (layout, word wrap, ignore whitespace, syntax colours, new files, tree or list, the file filters, the file list's width and visibility, which files you collapsed), the scope, the comparison base and the repository you picked are saved in Desktop plugin storage, with the commit button's default. They are keyed by profile and connection, so switching chats keeps your view. A request from the agent replaces the scope and repository.

git-review and the native Review pane

Hermes Desktop ships its own Review pane. The two answer different reading styles, and this table shows where each one is ahead. It is based on the Desktop source of Hermes core bf0203a7; native behaviour can change between Hermes versions.

git-reviewNative Review pane
How you read a changeEvery changed file stacked in one continuous scroll, like a pull requestA file tree; clicking a file opens that one file's diff below it, in a panel capped at 55% of the sidebar
Moving between filesScroll, click a file to jump, or Review next fileClick each file in turn
ScopesLast agent turn, Uncommitted, Staged, Unstaged, Branch, CommitsUncommitted, Branch (since the trunk), Last agent turn
Branch compared againstThe default branch, or any branch you pickThe default branch
HistoryPick any subset of the branch's commits, or step through them one at a timeBranch diff as a whole
LayoutUnified or split side by sideUnified
Hidden contextGaps say how many lines they hide and expand 20 at a time or all at onceThree context lines per change, no expansion
SearchFile paths and the changed lines themselves—
Cite lines into your messageYes, as @line:path:start-end—
Agent can open the viewgit_review_select tool—
Stage, unstagePer file (header or right-click) or all; partly staged files markedPer file or all
DiscardPer file or all, confirmed in Desktop's dialog; deletes only the new files it names, never an untracked folderPer file or all, confirmed; git clean -fd on the path
Commit, push, pull requestCommit, commit & push with a remembered default, AI-drafted message (same template), push and publish, create or open a PR or MRCommit, commit & push, AI-drafted message, create or open a PR
Repository hooks and filtersSkipped or refused unless you allow themRun
Syntax coloursBuilt-in tokenizer with theme huesShiki
Read-only switchread_only setting—
Changed-files countStatus bar, any workspace—
Shortcut⌘⌥G toggles, rebindable⌘G toggles
Change list in the chat—"N files changed" card under the agent's turn

Native still has two things git-review does not: Shiki's grammar-exact highlighting, and the card under an agent's turn. Neither is reachable from a plugin today: Desktop's plugin SDK does not export its highlighter, and has no slot under a turn.

Privacy and disclosure

  • Shell commands, reading. To show changes the backend runs git as a subprocess: rev-parse, status, diff, log, show, cat-file, ls-files, for-each-ref, branch, remote, merge-base, rev-list, config (to read the repository's own program settings) and hash-object (without -w, to compute the empty tree). For the Last agent turn snapshot it also runs add -A and write-tree with GIT_INDEX_FILE and GIT_OBJECT_DIRECTORY pointed at the plugin's own data directory, so the repository's index and object database are never written. External diff and textconv drivers are disabled, and every call overrides core.fsmonitor, core.hooksPath and log.showSignature. It also blanks the clean, smudge and process filter drivers that the repository itself defines, so a checkout cannot make the pane run its programs. Filters from your global and system git configuration, such as git-lfs, are left alone. Every call has a timeout and an output cap.
  • Shell commands, writing. Only when you press a button: add, reset/restore/rm --cached (unstage), restore --source=HEAD plus deleting the named new files (discard, after you confirm), commit, push, and gh pr create / glab mr create. Unless run_repo_programs is on, these run with hooks off and core.fsmonitor off, and are refused when the repository's own config names a program they would run. Paths are passed as literal pathspecs. read_only refuses all of them in the backend.
  • Network. For the pull or merge request lookup, the backend runs your local gh pr list or glab mr list for the checked-out branch; for Push and Create pull request, git push and gh/glab contact your remote with your existing login. gh and glab get only your GH_*, GITHUB*, GLAB_* and GITLAB_* environment, with prompts disabled. Generate commit message sends the diff of what you are about to commit, and your ten latest commit subjects, to the model of the focused chat through Hermes, the same request Desktop's own Review pane makes. The plugin itself contacts nothing else.
  • Reads outside its own data.
    • Files and history inside authorized repositories: the focused workspace, configured repos/roots, and the latest agent selection.
    • This profile's config.yaml, for the plugin settings and terminal.cwd.
    • The cwd column of the sessions table in this profile's state.db, opened read-only, so that recent chat workspaces appear without configuration.
    • A caller-supplied path never grants access to a repository.
  • Discovery scope. Repositories are found by scanning, at most two levels deep, the focused workspace and the working directories of recent chats, plus any configured repos/roots. A scan visits at most 256 directories and returns at most 128 repositories. It never follows symlinks and skips hidden directories, so credential and config directories are never entered. A filesystem root is never scanned, and a home directory is scanned only when it is the declared workspace: a chat that merely ran in your home directory does not expose every repository beneath it.
  • Plugin data. $HERMES_HOME/plugin-data/git-review/select.sqlite3 holds agent selection requests. $HERMES_HOME/plugin-data/git-review/turn-snapshots/ holds the Last agent turn snapshots: a copy of the working tree's tracked and untracked (not ignored) files, as git objects, taken when you send a message. The newest 16 are kept, none older than three days. Desktop plugin storage holds display settings and turn baselines. Your repositories change only through the write actions above.
  • Background activity. While the pane is open it polls the local backend: every 3 seconds for agent selections, every 5 seconds for the diff on live scopes, and every 15 seconds for the branch's push state. The status-bar count polls git status for the focused workspace every 15 seconds while Desktop is visible. When you send a message, the plugin records the turn's snapshot (git hashes only files that changed since the previous one). There are no background processes.
  • Credentials and telemetry. None. The plugin stores no credentials and reports no usage.
  • Sensitive code. Diffs stay in the pane. The only way code reaches the chat is a citation or drag that you make yourself.

Limits

  • Diffs above 8 MiB are refused with a note rather than silently truncated.
  • The commit list fetches up to 250 commits per request. Load older commits fetches more, so no history is unreachable.
  • Each unchanged-line expansion reads at most 5,000 lines.
  • Untracked files in a turn diff are capped at 200.
  • Display state is per workspace and profile, not per chat (see What the pane remembers).
  • Syntax colours come from a line tokenizer, not a grammar: a block comment or a multi-line string is coloured only on the lines that show its delimiters. Files over 3,000 diff rows and lines over 1,000 characters stay plain.
  • Writes act on the whole file. Staging or discarding single hunks or lines is not supported.
  • The animated clips and the commit-by-commit, search and commit-box screenshots are captured in Hermes Desktop. The other screenshots were captured from the plugin's own code, running against a real backend and real repositories, in a Chromium harness that stands in for the Desktop window.
  • A turn snapshot records untracked files up to 64 MiB in total. Above that, Last agent turn compares against the commit the turn started from.

Settings

The pane follows the focused chat's workspace automatically. To offer other repositories, open Settings → Plugins → git-review:

SettingMeaning
reposNewline-separated absolute repository paths.
rootsNewline-separated absolute directories to scan for worktrees (two levels deep, at most 256 directories).
read_onlyHide stage, discard, commit, push and PR, and refuse them in the backend. Off by default.
run_repo_programsLet writes run hooks, filter drivers, signing and SSH programs that a repository's own config names. Off by default.

Settings live under plugins.entries.git-review.settings. None of them are secrets.

Troubleshooting

SymptomCheck
No worktrees found / HTTP 403Open a chat whose workspace is a Git repository, or configure repos/roots.
Backend unavailableMake sure the plugin is enabled and the backend is running. Backend updates need a backend restart.
Diff exceeds display limitNarrow the scope, the selected commits or the file filter.
Pull/merge request button missingAuthenticate gh/glab and check that the branch has an open pull or merge request.
Pane missing or staleEnable the plugin, then run Reload desktop plugins from the command palette. If Desktop runs on another machine than the backend, install the plugin on that machine too.
A write says the repository's config names programsThe repository defines a hook-like program (filter driver, signing or SSH command, credential helper) in its own .git/config. Review it, then turn on run_repo_programs, or run that command in a terminal.
Push or Create pull request failsThe message is git's or gh's own. Check that git push works in a terminal, and that gh auth status (or glab auth status) is signed in.
No Generate commit message buttonYour Desktop does not offer plugins a gateway request. Update Hermes Desktop.
Commits list shows only a few commitsThe reviewed repository is a shallow clone (a plugin directory installed by Hermes is one). Run git fetch --unshallow in that repository.

Development

npm ci
npm test                 # unit, smoke and import-allowlist checks
python -m unittest discover -s tests -v
hermes plugins validate . --install-deps
python scripts/package.py

Python tests run against temporary real repositories and the actual FastAPI router. The Node tests render the real pane with test doubles for the Desktop SDK.

See CONTRIBUTING.md and SECURITY.md. Changelog: CHANGELOG.md.

Support, issues and releases

  • Bugs and feature requests: the issue forms. The bug form asks for your versions, the scope you had selected and the git-review log lines. That evidence is what makes a report reproducible.
  • Questions and ideas: Discussions.
  • Security: SECURITY.md. Report privately, never in a public issue.
  • Community expectations: CODE_OF_CONDUCT.md.
  • Contributing: CONTRIBUTING.md explains what is in and out of scope, and how releases are cut.

Releases are SemVer tags with a GitHub Release. The release workflow builds each zip only after the test suite passes, and published releases are immutable. The Hermes plugin catalog pins an exact commit, and moving that pin is a reviewed pull request against NousResearch/hermes-agent, so catalog users only receive reviewed code.

License

MIT. See LICENSE.

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

More by mister-ideas

2 plugins by mister-ideas in the catalog.

mister-ideasusage-guardKeeps an agent inside its subscription allowance: refuses a provider dispatch once a subscription usage window is exhausted, so an account that allows paid extra usage stops at the wall instead of spending overage. Reads the usage Hermes already displays, holds no credentials, and never touches account or billing settings. Disclosure — refuses main-loop provider calls (including MoA turns) for the providers in provider_keys (Anthropic and OpenAI Codex by default) when a subscription usage window reaches threshold_percent (a lone Anthropic reading of exactly 100% with extra usage off is treated as possibly 1%, because Hermes's Anthropic parser scales any utilization <= 1 by 100 until hermes-agent#139916, and passes; a 100% that follows a higher reading in the same window, or any 100% while extra usage is on, refuses), and by default (fail_open: false) also refuses when usage data is missing, stale, unreadable, or the guard's own config is malformed; usage is read through Hermes's own account-usage fetcher (no credentials held, at most one read per source every 180 seconds by default) and cached in $HERMES_HOME/plugin-data/usage-guard/usage.json; a pre_llm_call hook adds a short usage note to the next turn's context at 80% and 90% used by default, and an opt-in (off by default) llm_request middleware lowers an existing output-token budget near the usage limit; both read only the cache, never the network; a /usage-guard slash command and a Hermes Desktop status-bar chip (polling a read-only GET /api/plugins/usage-guard/status route every 60 s and after each turn) report the guard's decision from the same cache, never making a usage request; a refusal is an explanatory assistant message by default (refusal_mode: notice); with the opt-in refusal_mode: empty it is an empty reply instead, so Hermes's empty-response recovery retries (each retry refused again, never dispatched) and then switches to the profile's fallback_providers, which the guard gates only when they are listed in provider_keys; auxiliary calls (compression, vision, titles, MoA advisors) are not gated. Borrowing is off by default: when hydrate_from_paths names files, the guard may read those JSON snapshots instead of reading the endpoint, validating every window and never writing them into its own cache.Communityautomation3

Developer Mode

Explore built-in Hermes toolsets and actions.

HermesAgent

Developer?

Create a Hermes extension for Desktop or agent workflows.

Developer Section