All plugins

model-explainer

A Models page for Hermes Desktop built around your own model picker: choose a model to see its Hermes Index score, cost per task, context and output limits, price, abilities and your own measured speed and spend, with a score-against-cost frontier chart, and compare up to four side by side. Every value cites a source and date. Disclosure — one GET of a public JSON data file from the author's GitHub repo (raw.githubusercontent.com/tuancookiez-hub/hermes-model-explainer, main branch, so its contents can change after this pin), at most daily and only when the page opens (can be turned off; the bundled copy works offline; the file is validated data, never code); reads model.options and the focused session's model and usage figures; writes plugin storage, and switches the chat model only when the user presses Use this model (the same config.set request as the built-in picker, scoped to the open chat). Desktop only: no agent tools, hooks, middleware or env vars.

tuancookiez-hub1Modelsv0.3.0Updated 23 hours ago

About

A Models page for Hermes Desktop built around your own model picker: choose a model to see its Hermes Index score, cost per task, context and output limits, price, abilities and your own measured speed and spend, with a score-against-cost frontier chart, and compare up to four side by side. Every value cites a source and date. Disclosure — one GET of a public JSON data file from the author's GitHub repo (raw.githubusercontent.com/tuancookiez-hub/hermes-model-explainer, main branch, so its contents can change after this pin), at most daily and only when the page opens (can be turned off; the bundled copy works offline; the file is validated data, never code); reads model.options and the focused session's model and usage figures; writes plugin storage, and switches the chat model only when the user presses Use this model (the same config.set request as the built-in picker, scoped to the open chat). Desktop only: no agent tools, hooks, middleware or env vars.

Model Explainer for Hermes Desktop

Model Explainer

A Models page for Hermes Desktop built around your real model picker. The left
column is Hermes' own menu, so provider sections, names, -fast grouping, favorites
and your Edit Models shortlist are exactly what the composer shows. Choosing a row
explains that model, and Use this model switches your chat to it:

  • Hermes Index score and rank, with the per-suite breakdown (Hermes Bench,
    TerminalBench 4, TerminalBench Science, SkillsBench)
  • Cost per task on the Hermes Index
  • A score-against-cost frontier chart: every indexed model plotted and named, with the
    Pareto line joining models that score higher than everything cheaper. Switch the
    score (Hermes Index or any one suite) and the cost (cost per task, input price,
    output price, or a 3:1 blended token price) to see a different frontier. Each
    model says whether it is on the line and, if not, which model beats it. Click
    a dot to open that model.
  • Context window, max input, max output
  • Price per million tokens (reference host), plus the price Hermes reports
    for the provider you picked, when Hermes has it
  • Abilities (reasoning, tool calls, vision, PDF, audio, video, fast mode)
  • Your measured speed and spend: average tokens per second and cost, taken
    from Hermes' own usage stream while you chat. Nothing is estimated.
  • A one-line explanation for each model
  • A ranking of every scored model beside the picker; click one to open it
  • Compare up to four models side by side, with the strongest value in each row
    marked and all four highlighted on the frontier chart
  • A performance-by-reasoning-effort chart, shown only for models whose data
    includes a sourced curve (none do yet; see Data)

Every value shows its source and date. Hover a source to read it, click it to open
the page it came from. Figures measured on your machine are dated by your last run.

The picker also gets a small HI 63 badge on rows that have a Hermes Index
score. The badge goes through the Desktop SDK's model-menu decoration slot, so
the picker itself is untouched.

| | |
|---|---|
| Details | Frontier and suites |
| Sources | Compare |

Screenshots show the plugin page on its own, with a sample provider list.

Open it from the sidebar (Models) or ⌘K → Model Explainer: Open /
Explain current model.

What it touches (disclosure)

| | |
|---|---|
| Network | One GET of data/models.json from raw.githubusercontent.com, at most once a day and only when you open the page, plus the check button. It sends no cookies, no referrer and nothing about you or your models; GitHub sees your IP address, as with any download. Turn it off with Check daily when this page opens. The bundled copy keeps working offline. |
| Reads | model.options, through Hermes' own picker component, and the focused session's model, profile and usage figures (host.state.model, focusedSessionId, focusedSessionProfile, focusedUsage). |
| Writes | Your chat model, only when you press Use this model: it sends the same config.set model request as Hermes' own picker, scoped to the open chat (--session) so your default is left alone, and a guarded switch asks through Hermes' confirm dialog. Otherwise plugin storage only (ctx.storage, namespace hermes.plugin.model-explainer.*): your measured speed/spend per model (capped at 40 sessions × 200 models), the latest valid data file, when it was last checked, the daily-check switch and your compare list. Stars, the Edit Models shortlist and collapsed sections are Hermes' own picker settings, so changing them here changes them in the composer too. |
| Background work | One listener on the usage stream; storage is saved at most every 5 seconds while you chat. While the page is open, Hermes' picker re-reads prices the way it does in the composer (a few times over about 10 seconds, only while they are warming). Nothing else runs in the background. |
| Costs | None from the plugin: it makes no model calls. A model you switch to is billed by its provider as usual. |
| Credentials | None read or stored. |
| Agent side | None: no tools, hooks, middleware, slash commands or env vars. |

Measured speed is Hermes' rolling average over recent calls, so the first
two calls after a model switch are not counted. It reflects whichever provider
you used for that model.

Data

All model facts live in data/models.json, which is plain
data checked against data/schema.json. Each value has the
form { "v": <value>, "src": "<source id>" }, and each source records a URL,
retrieval date, license note and caveats.

Current sources:

  • Hermes Index (portal.nousresearch.com/bench):
    score, per-suite scores and cost per task. Every run is at high reasoning
    effort, so the index has no reasoning-level breakdown. The page has no
    snapshot date, so the retrieval date is used.
  • models.dev (models.dev, MIT): context, input and
    output limits, price, abilities. Prices are for the named host; others differ.
  • Maintainer: the one-line explanations, written from the values above.

Not used: Artificial Analysis (its terms forbid republishing) and OpenRouter
(its terms forbid scraping, and it lists resale prices).

Models without data are listed like any other, with whatever Hermes itself
reports, plus a button to suggest them.

Reporting a correction

Use Report a correction on any model, or open a
correction report. Include a
public source link. Accepted corrections change data/models.json only, and
reach users the next time their daily check runs.

Updating the data (maintainers)

# edit data/models.json, then:
node scripts/embed-data.mjs          # validates and embeds the data and validator into desktop/plugin.js
node scripts/embed-data.mjs --check  # what CI runs

Pushing data/models.json to main publishes it: installed copies pick it up
without a new plugin version. Re-embedding keeps the offline copy current for the
next release.

The downloaded file is data, never code. It is parsed with JSON.parse, checked
against the rules in scripts/validate-data.mjs (the
same rules CI runs), and shown as plain text. A file that is invalid, too large or
older than the one in use is ignored and the last good copy stays. Source links must
be https://. The plugin never fetches or replaces its own code. The worst a bad
data commit can do is show wrong numbers or link to the wrong page, so review data
changes like any other.

Install

hermes plugins install model-explainer

That name works once the catalog entry is merged. Until then, install from the repository:

hermes plugins install tuancookiez-hub/hermes-model-explainer

Then enable Model Explainer in Desktop → Capabilities → Plugins.

Requires Hermes ≥ 0.23.0.

License

MIT. Data from models.dev is MIT (sst/models.dev). Hermes Index figures are
quoted with attribution to Nous Research.

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

More by tuancookiez-hub

8 plugins by tuancookiez-hub in the catalog.

tuancookiez-hubhyatlasHyAtlas 5 — self-hosted 8-layer memory provider backed by a pure-Go single-binary server you run yourself (chromem-go vectors, in-process BGE-small embeddings, hybrid vector + keyword search, bitemporal knowledge graph with source citations). Embeddings, the vector index and stored memories are kept locally. Ships agent tools (hyatlas_status/search/recent/add), a `hermes hyatlas` CLI, a Desktop pane with a starmap graph view, and a web dashboard. Disclosure — requires the separate hyatlas-go server, installed by the user. The plugin never downloads or bundles it, and it talks only to the configured server (default 127.0.0.1:19528). Embeddings are computed locally; stored memories leave the machine only in the LLM calls described below. Extraction is opt-in and uses an LLM you choose: `hermes memory setup` asks for any OpenAI-compatible endpoint, model and key, and stores the key in Hermes's .env as HYATLAS_LLM_KEY. The plugin reads that key only through Hermes's get_secret and reads no Hermes credential. A plain key file named by HYATLAS_LLM_KEY_FILE also works; the server reads it on every call, so do not point it at another program's credentials such as Hermes auth.json. The server has no default endpoint and makes no LLM call until the endpoint, the model and a key are all present; while the endpoint and model are set but no key has arrived, /api/v1/status reports llm "awaiting_key". `hermes memory setup`, the repo installer and the sample launcher pre-fill a free Nous Portal endpoint and model (and setup defaults to ultra mode), but nothing is sent until a key is supplied. A server the plugin starts gets that key in its environment; for a server started another way (the launcher, a service) that reports "awaiting_key", the plugin (at most every 10 minutes) and `hermes hyatlas doctor` POST the key over plain HTTP to /api/v1/llm/key, only when the configured server host is this machine; the server accepts it only from a loopback address and keeps it in memory only, never on disk. Once configured, each turn's user and assistant text goes to that endpoint (not tool output or context summaries; capped at 12,000 characters), together with up to 5 related stored facts, 3 entity pages and 5 open intentions of that owner so the model can update them instead of duplicating them. In the default ultra mode the server also sends topic-grouped batches of up to 50 stored facts to it every 6 hours (every 20 minutes while earlier batches are still pending) and supersedes (hides but keeps) the facts the model marks merged or stale, recording a reason for each drop. It also records relations corroborated across turns in the local knowledge graph (HYATLAS_CONSOLIDATE_GRAPH=off disables that). Once a day per owner (HYATLAS_CROSS_SCHEMA_EVERY; off disables it) ultra also sends up to 40 of that owner's stored patterns to find up to 3 that hold across topics. In pro and ultra modes it also sends each owner's open intentions, recent summaries and newest facts to rewrite a short Now page, at most every 15 minutes (HYATLAS_NOW_EVERY), and, after a 30-minute pause in an owner's writes (HYATLAS_EPISODE_GAP; off disables it), up to 40 of that stretch's facts to write one episode summary. HYATLAS_RECONCILE=on (off by default) adds a second LLM call per write that sends the new facts together with similar stored ones (including those under user IDs grouped with the owner by HYATLAS_USER_ALIASES) so the model can update, replace or link them; it is meant for a local model. An optional HYATLAS_LLM_FALLBACK_MODEL, tried only when a primary call fails, receives the same text; it is sent the primary key only when it uses the same host. Turns written while the endpoint was unreachable or before a key arrived are extracted later by a catch-up pass (every 10 minutes by default, HYATLAS_CATCHUP_EVERY; rows up to 7 days old, HYATLAS_CATCHUP_MAX_AGE), sending the same text a write would have sent. `hermes hyatlas doctor` sends one short test prompt ("Reply with the single word OK.") to the endpoint and writes, finds and deletes one test memory. When you replace or remove an entry with Hermes's memory tool, the plugin asks the local server to retire the matching memory (reversible); nothing leaves the machine. HYATLAS_MODE=lite makes no LLM call. Server endpoints that rewrite stored data are off unless the server runs with HYATLAS_ADMIN=on. The spawned server gets an allowlisted environment (OS essentials plus HYATLAS_*), not the agent's keys. auto_start is off by default; when on, Hermes starts the server as soon as it loads the plugin, and a server started by auto_start or `hermes hyatlas start` keeps running after Hermes exits until `hermes hyatlas stop`. On Windows, if a hyatlas-go.ps1 launcher is configured, `hermes hyatlas start/stop` runs it; the repo's sample launcher reads no credentials (since 4.8.0 it no longer reads Hermes auth.json). No telemetry.Communitymemory31tuancookiez-hubenhance-promptA sparkle beside Send that rewrites the composer draft in place without sending it, deepening it into a clarifier, a task list, then a phased plan on further clicks, with a one-click discard back to the original. Also registers the `/enhance` slash command and the `enhance_prompt` tool for the same rewrite from the agent. Draft read and write go through `host.composer`, so `@file` and `/command` chips survive. Disclosure — every click runs one stateless `llm.oneshot` call on your own gateway with the focused chat's model (the auxiliary title model when no chat is focused), followed by a second short call to score the result, so it spends your model credits. It is not an agent turn: no tools run and nothing is written to a session you cannot see. It overrides no model, sends nothing to a third party, never sends the composer message, and carries no telemetry, no credentials and no self-update.CommunityDesktop app6tuancookiez-hubdiscord-tpsShow live tokens-per-second and the active model on your Discord bot's presence. Disclosure — Replaces the Discord bot's public presence with the live tok/s figure and the model name of the most recent API call in this gateway (any platform or chat), visible to anyone who can see the bot; updates at most every interval seconds (minimum 10) over the gateway's existing Discord connection. Reads no credentials and makes no network calls of its own.Communityplatform1tuancookiez-hubgif-toolShow, edit and compress GIFs in Hermes. `gif_open` turns any GIF, animated WebP, APNG, PNG or JPEG (a file path or an https link) into a card in Hermes Desktop where you add exact captions, change speed, reverse, boomerang, trim, drop frames and crop with a live preview; the original file is never changed. `gif_export` and the card's export buttons compress for Discord (10 MB), Discord emoji (256 KB), Telegram, X (5 MB), under 1 MB, animated WebP or a size you name, shrinking until the file fits and reporting before and after sizes (pure Pillow: shared palette, frame differencing, size-targeted ladder). `gif_edit` gives the agent the same edits. `gif_create` makes a four-frame meme GIF from a prompt. A GIF Studio tab lists every GIF in the profile and takes a dropped file or a pasted link. Disclosure — editing, previews and compression are local; opening a link downloads that one https URL (no cookies or credentials; private, local and link-local addresses refused, redirects and the connected peer re-checked; a GIPHY or Tenor page is followed once to its og:image); `gif_create` sends only the text prompt to chatgpt.com/backend-api/codex/images/generations through Hermes' credentialed_provider_request with the user's OpenAI Codex sign-in, using one image from the user's ChatGPT plan per call, via an undocumented endpoint; projects and rendered files are stored under the profile's plugin-data/gif-tool and cache/generated/images.CommunityDesktop app

Developer Mode

Explore built-in Hermes toolsets and actions.

HermesAgent

Developer?

Create a Hermes extension for Desktop or agent workflows.

Developer Section