All plugins

hermes-ui

A bespoke chat workspace for Hermes Desktop and the Webapp: it takes over the app's home route and replaces it with a three-column page — a rail of bots (one row per profile, each with its own conversations), the conversation itself with folded reasoning and one working line that says what the bot is doing (tool calls are not listed; a call waiting for permission still shows its card), and a right panel for files, previews and session detail. Bots can answer with a structured block that the thread draws as rich components (status cards, tables, checklists, approval prompts) instead of prose, its questions answered in the thread with buttons, a multi-select and free text; links open in the OS browser; messages written while the bot works wait in a queue under the composer and go in order, slash commands, per-bot models and a settings page come with it (a model switch is sent to config.set without the confirmation flag; when the gateway asks to confirm a costly or data-policy-sensitive switch, its own message is shown in a dialog and the flag is sent only after the user clicks Switch), and media blocks render images, audio and video inline. Disclosure — takes over the Desktop/Webapp home route by default: opening home or a session from the native sidebar redirects into Hermes UI (a palette command turns this off). Its side panel previews files that replies name (MEDIA: lines, attached-image paths) by reading them through the plugin's own backend routes, which accept any path under the profile home or the user's home directory except core-refused and credential files (.env*, auth.json, config.yaml, credentials, webhook_subscriptions.json, private keys, .ssh/.aws/.gnupg, secrets, mcp-tokens and pairing folders); those local previews stay on the device. Web images a reply links to (markdown images, MEDIA: web addresses) are loaded by the app straight from their host, with no referrer. The bots rail reads each profile's state.db read-only. Changing a bot's look (shape, eyes, colour) writes ui_meta['hermes-ui'] in that profile's profile.yaml through Hermes' own profiles.configure. No telemetry.

IlyassbmDesktopv1.8.1Updated 3 days ago

About

A bespoke chat workspace for Hermes Desktop and the Webapp: it takes over the app's home route and replaces it with a three-column page — a rail of bots (one row per profile, each with its own conversations), the conversation itself with folded reasoning and one working line that says what the bot is doing (tool calls are not listed; a call waiting for permission still shows its card), and a right panel for files, previews and session detail. Bots can answer with a structured block that the thread draws as rich components (status cards, tables, checklists, approval prompts) instead of prose, its questions answered in the thread with buttons, a multi-select and free text; links open in the OS browser; messages written while the bot works wait in a queue under the composer and go in order, slash commands, per-bot models and a settings page come with it (a model switch is sent to config.set without the confirmation flag; when the gateway asks to confirm a costly or data-policy-sensitive switch, its own message is shown in a dialog and the flag is sent only after the user clicks Switch), and media blocks render images, audio and video inline. Disclosure — takes over the Desktop/Webapp home route by default: opening home or a session from the native sidebar redirects into Hermes UI (a palette command turns this off). Its side panel previews files that replies name (MEDIA: lines, attached-image paths) by reading them through the plugin's own backend routes, which accept any path under the profile home or the user's home directory except core-refused and credential files (.env*, auth.json, config.yaml, credentials, webhook_subscriptions.json, private keys, .ssh/.aws/.gnupg, secrets, mcp-tokens and pairing folders); those local previews stay on the device. Web images a reply links to (markdown images, MEDIA: web addresses) are loaded by the app straight from their host, with no referrer. The bots rail reads each profile's state.db read-only. Changing a bot's look (shape, eyes, colour) writes ui_meta['hermes-ui'] in that profile's profile.yaml through Hermes' own profiles.configure. No telemetry.

Hermes UI

A bespoke chat workspace for Hermes Desktop and the Webapp: it replaces the native home with a three-column page —
the bots rail, the conversation, the right panel — and leaves the rest of the app alone.

Screenshots

Every screenshot is a real conversation in the Webapp, answered live by Claude Haiku 5.5 through the gateway —
nothing is mocked. Four demo bots, a throwaway profile, no account or usage data on screen.

A release-status card drawn by the bot: a checklist with states, details and a primary button

Intelligent UI. The bot answers with a <hui-ui> block and the thread draws it as Glaze components — here a status
card with a checklist and a button that sends its own follow-up. The bot's name above the thread opens all of its
conversations.

A comparison table with wrapped cells

A comparison as a table: long cells wrap instead of being cut at the edge.

The bot panel: its mark and name, then its conversations and routines

The bot panel. The open bot's mark and name, then two views: Activity (its conversations, the running one marked
live, and its routines with a switch that pauses or resumes them) and Files (what the conversation read, wrote or
ran).

An approval card: the command, why it was flagged, and Always allow / Refuse / Allow

Approvals inline. The card says why Hermes stopped (“recursive delete”) and answers in
one click — Always allow, Refuse, or the green Allow; the working line under the thread keeps the clock.

The model menu: effort on top, then the provider's models

The model menu, opened from the composer: Low / Medium / High effort, then each provider with its logo.

The slash command list with a description under each command

/ opens the profile's own commands, with the gateway's description of each.

The same thread in the light theme

Light theme (Settings ▸ Hermes UI ▸ Theme: System, Dark or Light).

The Hermes UI settings page

Settings ▸ Plugins ▸ Hermes UI: appearance, the chat defaults and the look of the open bot, and the plugin's shortcuts.

What you get

  • Bots rail with the pinned bots as tiles, then the team in the roster's own sections: one row per bot, its name
    and last line.
  • Floating bot pill above the thread: the open bot and conversation, and every conversation of the bot one click away.
  • Live activity line — thinking, working, delegating — that folds into “Worked for 12s” when the turn ends.
  • Reasoning folded under the reply as “Thought for 8s”, opened on demand. Tool calls are not listed in the thread:
    the activity line says what the bot is doing, and only a call waiting for your permission shows its card.
  • Queued messages: what you write while the bot works waits above the composer and goes, in order, when its turn
    ends (edit, reorder, remove, or send now).
  • Approval cards for the commands and tools that ask before they run, and question cards for the choices a
    bot asks mid-turn (free text when it offers none, and its own countdown).
  • Streaming replies, with the thread fading under the bot's badge instead of being cut off.
  • Rich replies: tables, code blocks, images.
  • Slash commands that execute — /help, /model, /new and the profile's own — from the composer.
  • Per-bot model and effort in the composer, with provider logos, a search field that names a model from any
    provider, and the full catalogue behind a submenu.
  • Bot panel: the bot's card, its conversations, its routines (pause and resume in place) and the files the
    conversation touched, with a preview.
  • Light / dark / system, density, reading width and reduced motion, in Settings.

Design

The page has its own visual language (src/styles/theme.css), laid over the vendored component library: the
platform's UI font at a 15px reading size, neutral surfaces with one clear step between the page, the rail and
anything raised, solid controls (no glass, no gradients), real elevation for what floats — menus, the bot pill — and
none for what sits in the page. Light and dark are both first-class. A bot's colour and shape come from Hermes' own
Bots roster when you picked one there.

Why this is not a prompt or a skill

A skill tells the agent what to do. This plugin changes what Hermes is: it registers a route the app renders in place
of its home, reads the gateway's own session events, and drives turns, approvals, attachments and slash commands
through the SDK. Nothing here is a wrapper around the chat — the thread, the rail, the panel and the composer are
components of this plugin, and the app's own pages (Settings, Capabilities, Messaging, Cron, Artifacts) stay intact
behind it.

Three things follow from that, and none of them are reachable from a prompt:

  • Per-bot memory of the model and the effort, written with the profile and restored on the next turn.
  • Attachments that actually reach the model — the page attaches the bytes through image.attach_bytes, checks the
    reply, and carries the returned absolute path into the prompt, which is what the vision tool resolves.
  • A stable reading of a stored conversation — a turn earns its place only if it has an answer or a tool it ran, so
    a resumed thread never paints a column of empty "Thought for a moment" rows.

Install

From the catalogue:

hermes plugins install Ilyassbm/hermes-ui --enable

From the desktop app: Capabilities → Plugins → Install from Git, and paste the repository URL.

From a local clone:

hermes plugins install file:///path/to/hermes-ui --enable

Then restart the app — desktop plugins load at launch. The page becomes the home: #/hui is what the app opens,
and the native chat routes redirect to it.

Keyboard shortcuts

KeysAction
⌥1 … ⌥9Go to bot 1 to 9, in the rail's order (pinned first)
⌘⌥NNew conversation with a bot… (type a digit 1–9 to pick one, Escape to close)
⌘⇧ONew conversation with the current bot
⌘⌥KSearch bots and conversations
⌘⌥BShow or hide the right panel
/Focus the composer and open the command list
⌘J / ⌃`The desktop's own dev panes

Every one of them is an ordinary keybind action, rebindable in Settings ▸ Keyboard Shortcuts. The plugin's own are
registered under hermes-ui.* (hermes-ui.search, hermes-ui.newChatWithBot, hermes-ui.toggleAside, …); the last
row is the desktop app's, not the plugin's. On Windows and Linux, ⌘ reads Ctrl.

Settings

Settings ▸ Plugins ▸ Hermes UI hosts the page, and the gear in the rail opens it: Appearance (theme, density,
reading width, animations), Chat (the default model, effort, send key and activity line for the open bot),
Shortcuts (the plugin's bindings with the combo the app really dispatches) and About (version, repository,
licence, what the plugin reaches on the network).

How it works

The plugin uses the Desktop plugin SDK only: ctx.registerRoute for /hui, ctx.registerPaletteCommand for the
palette entries, ctx.registerKeybind for the shortcuts, ctx.registerSettingsPage for Settings ▸ Plugins, and
host.request / host.onEvent for the gateway — a small dashboard backend served through the plugin host (/bots,
plus the panel's read-only /file and /blob) on top. The contributions go through the SDK's own areas (ctx.registerMany), so an older desktop ignores
what it does not know. There is no DOM reach into the app, no core override and no monkey-patching.

The interface is Glaze (design.how), with the components vendored in src/components/glaze and locked by lint —
glaze/no-shadow and glaze/no-raw-color — plus scripts/check-css.mjs, which refuses a global selector that
escaped .glaze.

Privacy and network

No telemetry. The page talks to your own Hermes gateway and to nothing else.

GET /api/plugins/hermes-ui/bots reads each profile's state.db read-only to show the last line each bot said.
No credential is read, held or returned by the backend.

The right panel's preview, and the thread's media blocks, are served by two read-only routes, GET /file?path=… (UTF-8 text, 1 MiB cap) and
GET /blob?path=… (base64, 8 MiB cap). Both resolve the path with expanduser().resolve() and refuse it (HTTP 400,
{"error": "refused"}) when it lands outside the profile home (HERMES_HOME, or the profile root Hermes reports) and
outside ~, when a symlink leads out of those trees, for everything Hermes itself refuses to read
(agent.file_safety.get_read_block_error: credential stores, vault/, browser-profile/, the skills hub cache…), and
for the files Hermes manages or keeps credentials in, wherever they sit: .env and .env.*, auth.json, auth.lock,
config.yaml, credentials, .git-credentials, webhook_subscriptions.json, .anthropic_oauth.json, google_*,
.netrc, .pgpass, .npmrc, .pypirc, *.pem, *.key, id_*, and anything under a .ssh/, .aws/, .gnupg/,
secrets/, mcp-tokens/ or pairing/ component. A model reply that names MEDIA:~/.aws/credentials is refused like
any other path. dashboard/test_file_routes.py covers each class on a throwaway home. Each profile's images
folder (<root>/images, <root>/profiles/<profile>/images) is allowed on its own, and nothing else of that profile is.
Directories, special files
and unreadable files are refused the same way; a path that does not exist is 404 {"error": "missing"}, and a file
over the cap is 413 {"error": "too_large", "size": …}. No traceback is ever returned.

Known limits

  • The page takes over the app's home route by reading the hash (#/ and #/<session>), the sanctioned door: it never
    touches the app's DOM. On a shell that loads plugins late, the first paint can be the native home for a moment
    before the page takes over; the sidebar entry Hermes UI always opens it.
  • The desktop half is a single plugin.js; older shells that read plugin sources through the 512 KiB preview path
    refuse anything larger. Update Hermes Desktop, or use the Webapp.

Compatibility

Hermes Desktop and the Webapp, >=0.23. The page works with any provider and model the profile already has; the
per-bot model menu lists only the providers the profile is authenticated for.

Development

npm ci
npm run build     # esbuild bundle + Tailwind + the checks
npm run lint
node scripts/build.mjs --install   # publish into a local Hermes home

npm run build runs the gates, in this order: check-menus, check-menu-open, check-model-menu, check-slash,
check-keybinds, check-overlay-unmount, check-request-timeouts, check-css, check-bundle, check-surface.
desktop/plugin.js is a committed artefact: the app loads it as-is, so it is rebuilt and committed with every change
under src/.

The UI linter reads ui-policy.json (fonts, sizes, control gaps, viewports) and the data-ui-* markers in the JSX.
Serve the page, then check it at a viewport and a colour scheme:

npm run lint:ui -- --url http://localhost:3000 --viewport 390x844 --scheme light

--out writes the JSON report (default cache/lint-ui.json), --keep saves the screenshot beside it, --ready sets
the selector that marks the page ready (default .glaze). Exit codes: 0 passed, 1 findings, 2 did not finish.

A look of its own

Every bot is drawn as a flat body with two capsule eyes: eight shapes, eight pairs of eyes, thirteen colours or any hex.
Change it from the bot's right-click menu in the rail (Change look) or by clicking its avatar in the panel; Auto
leaves a field to the bot's own (its colour and shape in Hermes' Bots roster, else drawn from its name), Shuffle tries
one, Back to automatic takes the look back.

The look is saved in the profile, under ui_meta['hermes-ui'].mark in profile.yaml, through profiles.configure with
the per-key revision Hermes uses for its own roster — so it follows the profile, and it never touches the hermes-bots
key Hermes writes. A mark is checked on the way in: an unknown shape, or a colour that is not hex, reads as "not set".

Credits

  • Glaze design system by design.how (MIT).
  • thinking-state and thinking-reasoning motion adapted from aicss (MIT, vendored with its LICENSE in src/vendor/aicss).
  • The bot's mark (one flat body, two capsule eyes) is drawn from scratch; the idea of a body, a pair of eyes and a colour to
    choose from is after bloub (MIT).
  • Layout and editor inspiration from OpenBot (no code, no asset copied; PolyForm Noncommercial).

License

MIT — see LICENSE.

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

More by Ilyassbm

2 plugins by Ilyassbm in the catalog.

Ilyassbmhermes-templatesShare a whole Hermes agent as one .htemplate bundle and install it from a single HTTPS link: identity (SOUL.md), config with accounts and endpoints stripped, skills, routines, MCP server definitions, memories only when the author opts in, and plugin ids. A recipe, not a clone — credentials, sessions, conversation history, logs, caches and workspace never travel. Publish puts the bundle in a GitHub repository and returns one permanent link (re-publishing updates the same URL); Install previews a link, a path or a dropped file and shows the template itself before anything is written (SOUL.md, each skill, every routine's schedule and prompt, every MCP command, risky settings such as hooks with their values). Install enforces what the packer promises on any bundle: config sanitized again (approval and consent policy — command_allowlist, hooks_auto_accept, approvals, security — is always removed and the preview shows what was removed), routines imported paused through Hermes' cron API, MCP servers set enabled: false; plugins already installed here are enabled unless --no-enable-plugins. Reinstalling the same link offers "Update v1.0.0 → v1.1.0" and keeps memories, sessions and .env. Disclosure — reads the selected profile under HERMES_HOME (config.yaml, SOUL.md, skills/, cron/jobs.json, mcp.json, memories/ when opted in) and writes a new profile directory plus its own bundles under plugin-data/; the page may read a bundle only from HERMES_HOME or the home directory, the CLI has no such limit. Network: one HTTPS GET to a URL the user pastes (HTTPS and public hosts only on the page; http, LAN and local accepted in the CLI; every redirect re-checked, 20 MB cap) and, only when the user presses Publish, the GitHub REST API to upload the bundle and download it back to prove the link before it is shown; republishing writes the file at the same public URL. Installs drop approval and consent policy (command_allowlist, hooks_auto_accept, approvals, security), import routines paused and turn MCP servers off; plugins already installed here are enabled unless --no-enable-plugins. Credentials: the optional GITHUB_TOKEN is read with agent.secret_scope under the named profile, never stored in a bundle, logged or returned. No shell, no telemetry, no self-updater.CommunityDesktop app

Developer Mode

Explore built-in Hermes toolsets and actions.

HermesAgent

Developer?

Create a Hermes extension for Desktop or agent workflows.

Developer Section