nesquena/hermes-webuiPublic

Hermes WebUI: The best way to use Hermes Agent from the web or from your phone!

AI summary: A lightweight, dependency-free vanilla JS web interface for controlling and interacting with the Hermes agent.

Stars
19.6K
+52 today
Forks
2.8K
Watchers
61
Open issues
387
Open PRs
610
Contributors
~436
Commits
12.9K
Branches
84

PythonMITCreated Mar 30, 2026Last push 1d agoLatest release v0.52.544+93 stars this week+525 this month

Quick answers

What is hermes-webui?
A lightweight, dependency-free vanilla JS web interface for controlling and interacting with the Hermes agent.
What does hermes-webui do?
Hermes Web UI provides a clean, dark-themed browser interface for the Hermes Agent, a sophisticated AI that runs on your server and learns over time. It solves the accessibility problem of command-line only agents by offering full feature parity in a highly responsive web app without the overhead of build steps or heavy frameworks. The architecture is purely Python and vanilla JavaScript, utilizing a three-panel layout to manage sessions, chat, and workspace file browsing simultaneously. It features a unique circular context ring for monitoring token usage and a comprehensive 'Control Center' for adjusting model parameters and agent settings. By offering a native-feeling web experience, it allows users to manage their autonomous server agent seamlessly from any device.
Who is hermes-webui for?
Users and administrators of the Hermes autonomous agent who prefer a graphical interface over terminal access, or need remote management capabilities. Requires an existing Hermes agent installation.
How do I get started with hermes-webui?
python app.py
How popular is hermes-webui on GitHub?
nesquena/hermes-webui has 19,582 stars and 2,848 forks on GitHub, and gained 93 stars in the last 7 days.
What license does hermes-webui use?
nesquena/hermes-webui is released under the MIT license.

Star history

since Jul 29, 2026
05K10K15KJul 2026Sep 2026Oct 2026Nov 2026
19.6K stars as of Nov 19, 2026. Measured daily since Jul 29, 2026; GitHub no longer exposes earlier star timestamps.

Update history

2 recorded
  • Nov 1, 2026New release v0.52.544 (previously v0.52.458).
  • Oct 20, 2026New release v0.52.458 (previously v0.52.113).

Contribution activity

commits per day, last 52 weeks
NovDecJanFebMarAprMayJunJulAugSepOctNovMonWedFri2025-11-16: 0 commits2025-11-17: 0 commits2025-11-18: 0 commits2025-11-19: 0 commits2025-11-20: 0 commits2025-11-21: 0 commits2025-11-22: 0 commits2025-11-23: 0 commits2025-11-24: 0 commits2025-11-25: 0 commits2025-11-26: 0 commits2025-11-27: 0 commits2025-11-28: 0 commits2025-11-29: 0 commits2025-11-30: 0 commits2025-12-01: 0 commits2025-12-02: 0 commits2025-12-03: 0 commits2025-12-04: 0 commits2025-12-05: 0 commits2025-12-06: 0 commits2025-12-07: 0 commits2025-12-08: 0 commits2025-12-09: 0 commits2025-12-10: 0 commits2025-12-11: 0 commits2025-12-12: 0 commits2025-12-13: 0 commits2025-12-14: 0 commits2025-12-15: 0 commits2025-12-16: 0 commits2025-12-17: 0 commits2025-12-18: 0 commits2025-12-19: 0 commits2025-12-20: 0 commits2025-12-21: 0 commits2025-12-22: 0 commits2025-12-23: 0 commits2025-12-24: 0 commits2025-12-25: 0 commits2025-12-26: 0 commits2025-12-27: 0 commits2025-12-28: 0 commits2025-12-29: 0 commits2025-12-30: 0 commits2025-12-31: 0 commits2026-01-01: 0 commits2026-01-02: 0 commits2026-01-03: 0 commits2026-01-04: 0 commits2026-01-05: 0 commits2026-01-06: 0 commits2026-01-07: 0 commits2026-01-08: 0 commits2026-01-09: 0 commits2026-01-10: 0 commits2026-01-11: 0 commits2026-01-12: 0 commits2026-01-13: 0 commits2026-01-14: 0 commits2026-01-15: 0 commits2026-01-16: 0 commits2026-01-17: 0 commits2026-01-18: 0 commits2026-01-19: 0 commits2026-01-20: 0 commits2026-01-21: 0 commits2026-01-22: 0 commits2026-01-23: 0 commits2026-01-24: 0 commits2026-01-25: 0 commits2026-01-26: 0 commits2026-01-27: 0 commits2026-01-28: 0 commits2026-01-29: 0 commits2026-01-30: 0 commits2026-01-31: 0 commits2026-02-01: 0 commits2026-02-02: 0 commits2026-02-03: 0 commits2026-02-04: 0 commits2026-02-05: 0 commits2026-02-06: 0 commits2026-02-07: 0 commits2026-02-08: 0 commits2026-02-09: 0 commits2026-02-10: 0 commits2026-02-11: 0 commits2026-02-12: 0 commits2026-02-13: 0 commits2026-02-14: 0 commits2026-02-15: 0 commits2026-02-16: 0 commits2026-02-17: 0 commits2026-02-18: 0 commits2026-02-19: 0 commits2026-02-20: 0 commits2026-02-21: 0 commits2026-02-22: 0 commits2026-02-23: 0 commits2026-02-24: 0 commits2026-02-25: 0 commits2026-02-26: 0 commits2026-02-27: 0 commits2026-02-28: 0 commits2026-03-01: 0 commits2026-03-02: 0 commits2026-03-03: 0 commits2026-03-04: 0 commits2026-03-05: 0 commits2026-03-06: 0 commits2026-03-07: 0 commits2026-03-08: 0 commits2026-03-09: 0 commits2026-03-10: 0 commits2026-03-11: 0 commits2026-03-12: 0 commits2026-03-13: 0 commits2026-03-14: 0 commits2026-03-15: 0 commits2026-03-16: 0 commits2026-03-17: 0 commits2026-03-18: 0 commits2026-03-19: 0 commits2026-03-20: 0 commits2026-03-21: 0 commits2026-03-22: 0 commits2026-03-23: 0 commits2026-03-24: 0 commits2026-03-25: 0 commits2026-03-26: 0 commits2026-03-27: 0 commits2026-03-28: 0 commits2026-03-29: 0 commits2026-03-30: 13 commits2026-03-31: 5 commits2026-04-01: 16 commits2026-04-02: 38 commits2026-04-03: 123 commits2026-04-04: 99 commits2026-04-05: 32 commits2026-04-06: 49 commits2026-04-07: 12 commits2026-04-08: 28 commits2026-04-09: 19 commits2026-04-10: 27 commits2026-04-11: 51 commits2026-04-12: 80 commits2026-04-13: 99 commits2026-04-14: 42 commits2026-04-15: 31 commits2026-04-16: 18 commits2026-04-17: 7 commits2026-04-18: 22 commits2026-04-19: 6 commits2026-04-20: 28 commits2026-04-21: 44 commits2026-04-22: 18 commits2026-04-23: 49 commits2026-04-24: 55 commits2026-04-25: 43 commits2026-04-26: 12 commits2026-04-27: 16 commits2026-04-28: 41 commits2026-04-29: 17 commits2026-04-30: 80 commits2026-05-01: 51 commits2026-05-02: 48 commits2026-05-03: 66 commits2026-05-04: 61 commits2026-05-05: 72 commits2026-05-06: 54 commits2026-05-07: 85 commits2026-05-08: 90 commits2026-05-09: 48 commits2026-05-10: 76 commits2026-05-11: 105 commits2026-05-12: 41 commits2026-05-13: 69 commits2026-05-14: 25 commits2026-05-15: 44 commits2026-05-16: 28 commits2026-05-17: 46 commits2026-05-18: 25 commits2026-05-19: 30 commits2026-05-20: 34 commits2026-05-21: 44 commits2026-05-22: 49 commits2026-05-23: 42 commits2026-05-24: 51 commits2026-05-25: 32 commits2026-05-26: 20 commits2026-05-27: 25 commits2026-05-28: 63 commits2026-05-29: 36 commits2026-05-30: 43 commits2026-05-31: 44 commits2026-06-01: 39 commits2026-06-02: 48 commits2026-06-03: 48 commits2026-06-04: 37 commits2026-06-05: 71 commits2026-06-06: 28 commits2026-06-07: 16 commits2026-06-08: 24 commits2026-06-09: 27 commits2026-06-10: 36 commits2026-06-11: 49 commits2026-06-12: 67 commits2026-06-13: 58 commits2026-06-14: 52 commits2026-06-15: 57 commits2026-06-16: 75 commits2026-06-17: 34 commits2026-06-18: 87 commits2026-06-19: 62 commits2026-06-20: 82 commits2026-06-21: 102 commits2026-06-22: 60 commits2026-06-23: 74 commits2026-06-24: 153 commits2026-06-25: 132 commits2026-06-26: 147 commits2026-06-27: 68 commits2026-06-28: 165 commits2026-06-29: 139 commits2026-06-30: 126 commits2026-07-01: 178 commits2026-07-02: 107 commits2026-07-03: 92 commits2026-07-04: 165 commits2026-07-05: 136 commits2026-07-06: 85 commits2026-07-07: 31 commits2026-07-08: 88 commits2026-07-09: 69 commits2026-07-10: 55 commits2026-07-11: 63 commits2026-07-12: 18 commits2026-07-13: 32 commits2026-07-14: 11 commits2026-07-15: 25 commits2026-07-16: 33 commits2026-07-17: 34 commits2026-07-18: 44 commits2026-07-19: 31 commits2026-07-20: 27 commits2026-07-21: 20 commits2026-07-22: 16 commits2026-07-23: 12 commits2026-07-24: 10 commits2026-07-25: 11 commits2026-07-26: 20 commits2026-07-27: 4 commits2026-07-28: 3 commits2026-07-29: 22 commits2026-07-30: 6 commits2026-07-31: 20 commits2026-08-01: 17 commits2026-08-02: 9 commits2026-08-03: 4 commits2026-08-04: 6 commits2026-08-05: 34 commits2026-08-06: 12 commits2026-08-07: 27 commits2026-08-08: 29 commits2026-08-09: 21 commits2026-08-10: 24 commits2026-08-11: 24 commits2026-08-12: 27 commits2026-08-13: 55 commits2026-08-14: 53 commits2026-08-15: 16 commits2026-08-16: 27 commits2026-08-17: 27 commits2026-08-18: 19 commits2026-08-19: 12 commits2026-08-20: 22 commits2026-08-21: 35 commits2026-08-22: 10 commits2026-08-23: 25 commits2026-08-24: 43 commits2026-08-25: 22 commits2026-08-26: 14 commits2026-08-27: 10 commits2026-08-28: 10 commits2026-08-29: 3 commits2026-08-30: 3 commits2026-08-31: 8 commits2026-09-01: 8 commits2026-09-02: 8 commits2026-09-03: 3 commits2026-09-04: 23 commits2026-09-05: 6 commits2026-09-06: 8 commits2026-09-07: 17 commits2026-09-08: 23 commits2026-09-09: 29 commits2026-09-10: 30 commits2026-09-11: 18 commits2026-09-12: 18 commits2026-09-13: 12 commits2026-09-14: 23 commits2026-09-15: 44 commits2026-09-16: 37 commits2026-09-17: 29 commits2026-09-18: 28 commits2026-09-19: 28 commits2026-09-20: 52 commits2026-09-21: 22 commits2026-09-22: 69 commits2026-09-23: 175 commits2026-09-24: 128 commits2026-09-25: 31 commits2026-09-26: 26 commits2026-09-27: 18 commits2026-09-28: 10 commits2026-09-29: 62 commits2026-09-30: 23 commits2026-10-01: 84 commits2026-10-02: 94 commits2026-10-03: 49 commits2026-10-04: 25 commits2026-10-05: 65 commits2026-10-06: 186 commits2026-10-07: 107 commits2026-10-08: 127 commits2026-10-09: 78 commits2026-10-10: 170 commits2026-10-11: 42 commits2026-10-12: 41 commits2026-10-13: 111 commits2026-10-14: 117 commits2026-10-15: 68 commits2026-10-16: 132 commits2026-10-17: 100 commits2026-10-18: 21 commits2026-10-19: 155 commits2026-10-20: 49 commits2026-10-21: 112 commits2026-10-22: 124 commits2026-10-23: 27 commits2026-10-24: 16 commits2026-10-25: 16 commits2026-10-26: 10 commits2026-10-27: 146 commits2026-10-28: 56 commits2026-10-29: 136 commits2026-10-30: 122 commits2026-10-31: 136 commits2026-11-01: 62 commits2026-11-02: 34 commits2026-11-03: 109 commits2026-11-04: 72 commits2026-11-05: 96 commits2026-11-06: 53 commits2026-11-07: 26 commits2026-11-08: 23 commits2026-11-09: 67 commits2026-11-10: 27 commits2026-11-11: 58 commits2026-11-12: 13 commits2026-11-13: 0 commits2026-11-14: 0 commits
11,416 commits in the last yearLessMore

Signals and awards

derived from tracked data
  • Widely adopted

    19,582 stars

  • Very active

    11,416 commits in 52 weeks

  • Community-driven

    ~436 contributors

  • Outside contributions

    97% of recent commits from the community

  • Permissive license

    MIT

  • Continuous integration

    Automated checks passing

  • Repeat trending

    4 trending appearances

What hermes-webui does

Hermes Web UI provides a clean, dark-themed browser interface for the Hermes Agent, a sophisticated AI that runs on your server and learns over time. It solves the accessibility problem of command-line only agents by offering full feature parity in a highly responsive web app without the overhead of build steps or heavy frameworks. The architecture is purely Python and vanilla JavaScript, utilizing a three-panel layout to manage sessions, chat, and workspace file browsing simultaneously. It features a unique circular context ring for monitoring token usage and a comprehensive 'Control Center' for adjusting model parameters and agent settings. By offering a native-feeling web experience, it allows users to manage their autonomous server agent seamlessly from any device.

Users and administrators of the Hermes autonomous agent who prefer a graphical interface over terminal access, or need remote management capabilities. Requires an existing Hermes agent installation.

  • Zero dependency architecture: Built entirely with vanilla JavaScript and Python, requiring no bundlers, frameworks, or build steps.
  • Three-panel interface: Simultaneously displays session navigation, the active chat interface, and a local workspace file browser.
  • Context monitoring ring: Features a visual, circular indicator that displays real-time token usage and context window limits.
  • Full CLI parity: Ensures that every action available in the Hermes terminal interface is accessible through the web UI.
  • Integrated control center: Centralizes all agent settings, model selection, and profile management into a single, accessible launcher.

Where teams use it

Remote agent management

Server administrators can securely access and control their long-running Hermes agent from a mobile browser or remote desktop.

Visual workspace browsing

Users interacting with the agent's file generation capabilities can easily browse and manage the output directory via the UI's right panel.

Monitoring token consumption

Power users can keep strict tabs on their LLM API usage using the visual context ring while the autonomous agent runs complex tasks.

Frictionless deployment

Developers can instantly spin up the interface without dealing with npm installs, Webpack configurations, or React version conflicts.

Getting started: python app.py

README

master branch

Hermes Web UI

Hermes Agent is a sophisticated autonomous agent that lives on your server, accessed via a terminal or messaging apps, that remembers what it learns and gets more capable the longer it runs.

Hermes WebUI is a lightweight, dark-themed web app interface in your browser for Hermes Agent. Full parity with the CLI experience - everything you can do from a terminal, you can do from this UI. No build step, no framework, no bundler. Just Python and vanilla JS.

Layout: three-panel. Left sidebar for sessions and navigation, center for chat, right for workspace file browsing. Model, profile, and workspace controls live in the composer footer — always visible while composing. A circular context ring shows token usage at a glance. All settings and session tools are in the Hermes Control Center (launcher at the sidebar bottom).

Setup Hermes so you can access it natively on every device:

image
Light mode with full profile support
Light mode with full profile support
Customize your settings, configure a password
Customize your settings, configure a password
Workspace file browser with inline preview
Workspace file browser with inline preview
Session projects, tags, and tool call cards
Session projects, tags, and tool call cards

This gives you nearly 1:1 parity with Hermes CLI from a convenient web UI which you can access securely through an SSH tunnel from your Hermes setup. Single command to start this up, and a single command to SSH tunnel for access on your computer. Every single part of the web UI uses your existing Hermes agent and existing models, without requiring any additional setup.


Contents

image


Why Hermes

Most AI tools reset every session. They don't know who you are, what you worked on, or what conventions your project follows. You re-explain yourself every time.

Hermes retains context across sessions, runs scheduled jobs while you're offline, and gets smarter about your environment the longer it runs. It uses your existing Hermes agent setup, your existing models, and requires no additional configuration to start.

What makes it different from other agentic tools:

  • Persistent memory — user profile, agent notes, and a skills system that saves reusable procedures; Hermes learns your environment and does not have to relearn it
  • Self-hosted scheduling — cron jobs that fire while you're offline and deliver results to Telegram, Discord, Slack, Signal, email, and more
  • 10+ messaging platforms — the same agent available in the terminal is reachable from your phone
  • Self-improving skills — Hermes writes and saves its own skills automatically from experience; no marketplace to browse, no plugins to install
  • Provider-agnostic — OpenAI, Anthropic, Google, DeepSeek, OpenRouter, and more
  • Orchestrates other agents — can spawn Claude Code or Codex for heavy coding tasks and bring the results back into its own memory
  • Self-hosted — your conversations, your memory, your hardware

vs. the field (landscape is actively shifting — see docs/why-hermes.md for the full breakdown):

OpenClaw Claude Code Codex CLI OpenCode Hermes
Persistent memory (auto) Yes Partial† Partial Partial Yes
Scheduled jobs (self-hosted) Yes No‡ No No Yes
Messaging app access Yes (15+ platforms) Partial (Telegram/Discord preview) No No Yes (10+)
Web UI (self-hosted) Dashboard only No No Yes Yes
Self-improving skills Partial No No No Yes
Python / ML ecosystem No (Node.js) No No No Yes
Provider-agnostic Yes No (Claude only) Yes Yes Yes
Open source Yes (MIT) No Yes Yes Yes

† Claude Code has CLAUDE.md / MEMORY.md project context and rolling auto-memory, but not full automatic cross-session recall
‡ Claude Code has cloud-managed scheduling (Anthropic infrastructure) and session-scoped /loop; no self-hosted cron

The closest competitor is OpenClaw — both are always-on, self-hosted, open-source agents with memory, cron, and messaging. The key differences: Hermes writes and saves its own skills automatically as a core behavior (OpenClaw's skill system centers on a community marketplace); Hermes is more stable across updates (OpenClaw has documented release regressions and ClawHub has had security incidents involving malicious skills); and Hermes runs natively in the Python ecosystem. See docs/why-hermes.md for the full side-by-side.


Quick start

Run the repo bootstrap:

git clone https://github.com/nesquena/hermes-webui.git hermes-webui
cd hermes-webui
python3 bootstrap.py

Or keep using the shell launcher:

./start.sh

For self-hosted VM or homelab installs, ctl.sh wraps the common daemon lifecycle commands without requiring fuser or pkill:

./ctl.sh start              # background daemon, PID at ~/.hermes/webui.pid
./ctl.sh status             # PID, uptime, bound host/port, log path, /health
./ctl.sh logs --lines 100   # tail ~/.hermes/webui.log
./ctl.sh restart
./ctl.sh stop

ctl.sh start runs the bootstrap in foreground/no-browser mode behind the daemon wrapper, writes logs to ~/.hermes/webui.log, and respects .env plus inline overrides such as HERMES_WEBUI_HOST=0.0.0.0 ./ctl.sh start.

Stopping the server. Each launch method has its own stop path because only ctl.sh start writes a PID file (~/.hermes/webui.pid):

Launch method How to stop
python3 bootstrap.py Ctrl-C in the terminal (runs in the foreground)
./ctl.sh start ./ctl.sh stop (sends SIGTERM, waits, then SIGKILL)
Detached bootstrap.py (no --foreground) or ./start.sh Find the PID via lsof -i :8787 (or ss -tlnp) and kill it

./ctl.sh stop cannot stop a server launched by bootstrap.py or start.sh directly — it only manages processes it started itself.

How chat runs by default. WebUI runs the Hermes agent in-process, reading your HERMES_HOME config directly. It does not connect to an external Hermes/agent OpenAI-compatible API server to run chat. HERMES_API_URL is only read by the Tasks/cron health probe and does not route chat.

Two options if you run an external endpoint:

  1. Use its models as a chat provider (supported today): add it in Settings → Providers as a custom OpenAI-compatible provider with base_url = http://127.0.0.1:8642/v1 and your bearer token.
  2. Route chat through a Hermes Gateway API server (supported today via HERMES_WEBUI_CHAT_BACKEND=gateway): see docs/advanced-chat-setup.md. Full agent-loop delegation is not yet shipped; tracked in #1925.

Advanced: dynamic recall prefill & Gateway-backed chat

Two optional, self-hosted-deployment features — attaching dynamic session-recall prefill to browser turns (Joplin/Obsidian/Notion/llm-wiki routers), and routing browser chat through a running Hermes Gateway — are documented in docs/advanced-chat-setup.md. Most users need neither.

The bootstrap will:

  1. Detect Hermes Agent and, if missing, attempt the official installer (curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash).
  2. Find or create a Python environment with the WebUI dependencies.
  3. Start the web server and wait for /health.
  4. Open the browser unless you pass --no-browser.
  5. Drop you into a first-run onboarding wizard inside the WebUI.

Native Windows is not supported for this bootstrap yet. Use Linux, macOS, or WSL2. For Windows / WSL auto-start at login, see docs/wsl-autostart.md.

A community-maintained native Windows setup is documented at @markwang2658/hermes-windows-native-guide (companion setup repo: @markwang2658/hermes-windows-native). Notes from the community report in #1952:

  • Memory: community-measured ~330 MB native vs ~1080 MB with WSL2+Docker (varies by configuration).
  • What works: chat, workspace browser, session management, all themes.
  • Known limitations: some POSIX-style file paths surface in the workspace browser; bash-assuming agent tools may not work natively.
  • Native Windows setup: install Python 3.11+, then from the hermes-agent root in PowerShell: python -m venv venv → pip install -r requirements.txt → pwsh .\start.ps1 (it auto-discovers venv\Scripts\python.exe).
  • WSL2 relationship: not a prerequisite — a WSL2-built venv (venv/bin/python, ELF) isn't invokable by native Windows Python, so use the native setup above. WSL2 stays useful as a parallel install if you want the full bootstrap.py + Linux runtime.

If provider setup is still incomplete after install, the onboarding wizard will point you to finish it with hermes model instead of trying to replicate the full CLI setup in-browser. For a step-by-step walkthrough of the wizard, provider choices, local model server Base URLs, and safe re-runs, see docs/onboarding.md. If an AI assistant is helping with install, reinstall, bootstrap, provider setup, or first-run support, have it read docs/onboarding-agent-checklist.md before running commands or inspecting logs.


Features

Chat and agent

  • Streaming responses via SSE (tokens appear as they are generated)
  • Multi-provider model support -- any Hermes API provider (OpenAI, Anthropic, Google, DeepSeek, Nous Portal, OpenRouter, MiniMax, Xiaomi MiMo, Z.AI); dynamic model dropdown populated from configured keys
  • Send a message while one is processing -- it queues automatically
  • Edit any past user message inline and regenerate from that point
  • Retry the last assistant response with one click
  • Cancel a running task directly from the composer footer (Stop button next to Send)
  • Tool call cards inline -- each shows the tool name, args, and result snippet; expand/collapse all toggle for multi-tool turns
  • Subagent delegation cards -- child agent activity shown with distinct icon and indented border
  • Detached child results are delivered to the parent as internal wakeups. Their raw prompts and completion toasts do not appear as messages from the user; the parent can summarize the results in its own reply. Ordinary background-process wakeups remain visible. A completed parent reply does not, by itself, cancel or suppress outstanding children; a later result may still start a follow-up turn.
  • Mermaid diagram rendering inline (flowcharts, sequence diagrams, gantt charts)
  • Thinking/reasoning display -- collapsible gold-themed cards for Claude extended thinking and o3 reasoning blocks
  • Approval card for dangerous shell commands (allow once / session / always / deny)
  • SSE auto-reconnect on network blips (SSH tunnel resilience)
  • File attachments persist across page reloads and are stored outside the active workspace by default (~/.hermes/webui/attachments/<session_id>/, or HERMES_WEBUI_ATTACHMENT_DIR/<session_id>/ when configured)
  • Message timestamps (HH:MM next to each message, full date on hover)
  • Code block copy button with "Copied!" feedback
  • Syntax highlighting via Prism.js (Python, JS, bash, JSON, SQL, and more)
  • Safe HTML rendering in AI responses (bold, italic, code converted to markdown)
  • Bare HTTP(S) URLs are auto-linked without absorbing adjacent CJK prose; Unicode IDN host separators and raw-CJK IRI paths remain linkable
  • Local file links: a file:/// URI in a reply renders through the media route (inline preview for images/audio/video, download otherwise). Windows drive-letter URIs (file:///C:/...) resolve to the drive path on a Windows server; on a POSIX server the leading separator is preserved so a /C:/... request stays absolute and can never alias a workspace-relative file. Only local authorities are served — a file://<host>/... UNC reference is rejected (never silently rewired to a local path), and the file must live under an allowed root (HERMES_HOME, /tmp, the active workspace, or MEDIA_ALLOWED_ROOTS)
  • rAF-throttled token streaming for smoother rendering during long responses
  • Context usage indicator in composer footer -- token count, cost, and fill bar (model-aware)

Sessions

  • Create, rename, duplicate, delete, search by title and message content
  • Session actions via ⋯ dropdown per session — pin, move to project, archive, duplicate, delete
  • Pin/star sessions to the top of the sidebar (gold indicator)
  • Pinned-conversation limits apply separately to each session's owning profile; root/default aliases share a limit. Unpin an empty session before switching its profile through chat or /goal.
  • Archive sessions (hide without deleting, toggle to show)
  • Session projects -- named groups with colors for organizing sessions; delegated subagent sessions have no project of their own and follow their nearest ancestor's project in the project filter and the Unassigned chip; forks and other child sessions keep their own project, so a fork moved to "No project" stays Unassigned
  • Delegated subagent sessions nest under their parent row. When that parent is filtered out of the current view (project, source tab, hidden), the subagent is hidden with it rather than shown as a stray top-level "Subagent Session"; a subagent without the cross-surface flag (for example in the all-profiles view) stays a top-level row when its parent is in the other (CLI/TUI) tab, was never imported, or is itself shown as a top-level subagent row, and a subagent that matches an active sidebar search is always listed
  • Project bindings -- right-click a project chip and pick Project settings… to pin a default workspace (or several workspaces, with one marked default) and a model. The chip's + (and New Chat while the project filter is active) then opens a session already in that workspace/model. The reasoning-effort binding stays in the API (POST /api/projects/bind) but is dormant: the dialog no longer offers the row, and nothing applies a stored value to a new session any more — the only mechanism would be the profile-wide reasoning-effort preference (the same agent.reasoning_effort setting the /reasoning command writes), so a row inside a per-project dialog read as per-project while silently moving the whole profile's effort; it comes back with per-session effort (#7881)
  • Session tags -- add #tag to titles for colored chips and click-to-filter Clicking a session tag chip filters the list without opening the conversation.
  • Grouped by Today / Yesterday / Earlier in the sidebar (collapsible date groups)
  • Download as Markdown transcript, full JSON export, or import from JSON
  • Create a public read-only share link for the active conversation from the Control Center; shared pages show a sanitized transcript snapshot without workspace, profile, or live controls
  • Sessions persist across page reloads and SSH tunnel reconnects
  • Model and reasoning-effort selections are restored per session; new-session defaults and legacy-session reasoning fallback use that session's profile configuration, including an authoritative HERMES_CONFIG_PATH for root; named profiles use their own config.yaml unless the override resolves inside that profile home
  • Browser tab title reflects the active session name
  • CLI session bridge -- CLI sessions from hermes-agent's SQLite store appear in the sidebar with a gold "cli" badge; click to import with full history and reply normally
  • Token/cost display -- input tokens, output tokens, estimated cost shown per conversation (toggle in Settings or /usage command)

Workspace file browser

  • Directory tree with expand/collapse (single-click toggles, double-click navigates)
  • Breadcrumb navigation with clickable path segments
  • Preview text, code, Markdown (rendered), and images inline
  • Chat links using workspace://path/to/file open files in the right-side preview pane
  • Edit, create, delete, and rename files; create folders
  • Binary file download (auto-detected from server)
  • File preview auto-closes on directory navigation (with unsaved-edit guard)
  • Dismissing the workspace panel is respected: resizing the viewport or showing the on-screen keyboard no longer force-reopens the panel after you close it (#6710)
  • Previews report their real load outcome -- a broken source is reported as a failure instead of a silent success -- and a response that never settles is released by a bounded wait so the panel still opens; the source keeps loading and a late failure is surfaced in the status line (#6710)
  • Git detection -- branch name and dirty file count badge in workspace header
  • Right panel is drag-resizable
  • Syntax highlighted code preview (Prism.js)

Voice input

  • Microphone button in the composer (Web Speech API)
  • Tap to record, tap again or send to stop
  • Live interim transcription appears in the textarea
  • Auto-stops after ~2s of silence
  • Appends to existing textarea content (doesn't replace)
  • Hidden when browser doesn't support Web Speech API (Chrome, Edge, Safari)
  • A saved fallback from browser speech recognition to server-side recording expires after 24 hours. Preferences stored by older versions get a 24-hour window on first use after upgrading. On reload after expiry, the mic returns to normal capture selection: server transcription takes priority when available; otherwise it uses browser speech recognition.

Profiles

  • Profile chip in the composer footer -- dropdown showing all profiles with gateway status and model info
  • Gateway status dots (green = running), model info, skill count per profile
  • Profiles management panel -- create, switch, and delete profiles from the sidebar
  • Clone config from active profile on create
  • Optional custom endpoint fields on create -- Base URL and API key written into the profile's config.yaml at creation time, so Ollama, LMStudio, and other local endpoints can be configured without editing files manually
  • Seamless switching -- no server restart; reloads config, skills, memory, cron, models
  • Per-session profile tracking (records which profile was active at creation)

Authentication and security

  • Optional password auth -- off by default, zero friction for localhost
  • Enable via HERMES_WEBUI_PASSWORD env var or Settings panel
  • Installed PWAs work best with WebUI's own password. Reverse proxies are supported, but proxy basic auth can block the service-worker update fetches an installed app needs and leave it on a blank screen after an update; see docs/troubleshooting.md for recovery steps.
  • Optional passkeys/WebAuthn -- register from Settings -> System after signing in with a password; the login page only shows passkey sign-in after at least one passkey exists
  • After registering at least one passkey, Settings -> System can remove the password and keep passkey-only sign-in enabled. Password auth remains the bootstrap/recovery path until you choose to go passwordless; passkeys are same-origin and stored locally in the WebUI state directory
  • Optional native OIDC login for WebUI sessions -- configure webui_oidc.issuer, client_id, allow_claim, and allow_values in config.yaml, or set the matching HERMES_WEBUI_OIDC_* environment variables. OIDC stays disabled until all four are present, and startup prints a warning if the config is partial.
  • Native OIDC sends the client secret in the token-request form body (client_secret_post) by default. When the provider's discovery document only advertises client_secret_basic in token_endpoint_auth_methods_supported (common with strict OIDC stacks such as zitadel/oidc), the secret automatically moves to the HTTP Basic header instead. Set webui_oidc.token_auth_method (or HERMES_WEBUI_OIDC_TOKEN_AUTH_METHOD) to client_secret_basic or client_secret_post to pin a method explicitly.
  • Native OIDC stores the PKCE/state nonce flow in process memory. That works for the shipped single-process server, and it also works behind a load balancer when callbacks stay sticky to the same WebUI instance. Multi-instance deployments need session affinity, or the callback can land on a different process and fail state validation.
  • Signed HMAC HTTP-only cookie with 24h TTL
  • Minimal dark-themed login page at /login
  • Security headers on all responses (X-Content-Type-Options, X-Frame-Options, Referrer-Policy)
  • 20MB POST body size limit
  • CDN resources pinned with SRI integrity hashes

Themes

  • Appearance is split into two axes: Theme (system, dark, light) and Skin (default, ares, mono, slate, poseidon, sisyphus, charizard, sienna, catppuccin, nous, geist-contrast / Geist Contrast)
  • Switch via Settings -> Appearance (instant live preview) or /theme <theme-or-skin>
  • Persists across reloads (server-side in settings.json + localStorage for flicker-free loading)
  • Skins use data-skin plus CSS variables; dark mode resolves through the .dark class, not a data-theme custom-theme axis — see THEMES.md

Settings and configuration

  • Hermes Control Center (sidebar launcher button) -- Conversation tab (export/import/clear), Preferences tab (model, send key, theme, language, all toggles), System tab (version, password)
  • Send key: Enter (default) or Ctrl/Cmd+Enter
  • Send-key on touch devices: plain Enter inserts a newline on phones (iPhone/iPod, Android phones) and on tablets / iPadOS / touch-capable Macs that only expose a coarse pointer (no attached hardware keyboard), matching the software keyboard's return key. Devices that report a fine pointer (for example, a tablet with a hardware keyboard) keep the configured physical-keyboard send-key behavior. The configured shortcut and the Send button remain available for sending.
  • Show/hide CLI sessions toggle (enabled by default)
  • Token usage display toggle (off by default, also via /usage command)
  • Task list in chat toggle (off by default) -- a collapsible task strip pinned at the top of the chat area, summarising the current session's todos. While it is on, the sidebar Todos panel is hidden and the workspace-panel Todos toggle is disabled with an explanation, so the same list is never shown twice; switch it back off in Settings -> Appearance to restore the sidebar panel and re-enable the workspace toggle.
  • Control Center always opens on the Conversation tab; resets on close
  • Unsaved changes guard -- discard/save prompt when closing with unpersisted changes
  • Cron completion alerts -- toast notifications and unread badges scoped to the active profile on the Tasks tab and session sidebar
  • Background agent error alerts -- banner when a non-active session encounters an error
  • Approval and clarification browser alerts notify once per pending owner when its session is not actively viewed. Local approval dismissal hides attention without resolving the prompt; resolution, replacement, and cancellation retire that owner's alert state. Denied or failed notification delivery can retry while the prompt remains pending.

Slash commands

  • Type / in the composer for autocomplete dropdown
  • Plain skills match case-insensitive keywords in their name or description; built-in, agent/plugin, and bundle commands keep prefix matching and take precedence over a same-slug skill
  • Built-in: /help, /clear, /compress [focus topic], /compact (alias), /model <name>, /workspace <name>, /new, /usage, /theme
  • Arrow keys navigate, Tab/Enter select, Escape closes
  • Unrecognized commands pass through to the agent
Model aliases in /model

/model <alias> accepts any alias configured for the profile, in either of Hermes's two formats:

model_aliases:                     # canonical
  sol:
    model: gpt-5.6-sol
    provider: openai-codex

model:
  provider: openrouter
  aliases:                         # legacy
    sol: openai-codex/gpt-5.6-sol  # provider-qualified
    fast: gpt-4                    # unqualified

Alias resolution follows the format of the alias:

  • A canonical model_aliases entry and a provider-qualified legacy target name their own route. The target is authoritative, so /model sol selects that provider even when a same-named model exists on another provider. A canonical entry also takes precedence over a legacy entry with the same name.
  • An unqualified legacy target names only a model, so it keeps the ordinary lookup: the active provider first, then the normal fuzzy match. This is the behavior /model had before, and it is unchanged.

Aliases that carry their own endpoint or credentials are resolved server-side; the browser only receives the model, the provider id, and an opaque route id, never a base URL or key. On the in-process backend, an alias with its own base_url follows Hermes's direct-alias credential rules: its declared api_key/key_env wins; otherwise only a credential resolved for that endpoint's own host is sent (for example an OpenRouter key to openrouter.ai), never the provider label's key to an unrelated host. The alias's provider still selects its wire protocol.

Gateway and runner chat support provider-only aliases by sending the resolved target model and provider, not the alias name: their runtime does not share WebUI's alias registry. Aliases that explicitly declare base_url, api_key, or key_env need the in-process backend. External chat starts, wakeups, Gateway regeneration, and Gateway goal kickoffs reject them with HTTP 400 and reason: model_alias_requires_in_process_backend before dispatch; a new Gateway goal is not set. Runner regeneration remains unsupported (HTTP 409), regardless of alias selection. Ambient credentials resolved for a provider-only alias do not count as alias overrides. The session retains its target model and profile-bound opaque route id, including Gateway success/error writeback, so a later backend switch can still resolve the original alias.

A session stores that opaque route id, not the endpoint, so an alias that is later deleted or renamed leaves the session pointing at a route nothing owns. That send fails closed — on every backend, the in-process worker, the gateway and the runner alike — with a controlled "model alias unavailable" error instead of quietly falling back to another provider; pick the model again to store a live route.

With HERMES_WEBUI_RUNTIME_ADAPTER=runner-local, /goal <text> returns HTTP 501 (status: unsupported) without changing an existing goal or starting a run. The runner contract does not yet provide atomic goal replacement and kickoff; WebUI never substitutes local goal execution. /goal status, pause, resume, and clear delegate to the runner when supported. Legacy-direct and legacy-journal goal kickoff behavior is unchanged for supported routes. Normal runner chat supports provider-only model aliases.

Server-initiated turns retain the pre-session stale-Agent-runtime barrier. It runs before loading the session; named-profile alias and Gateway routing happen only after admission. A stale default local runtime can therefore reject a wakeup before the session's named-profile Gateway ownership is known.

Panels

  • Chat -- session list, search, pin, archive, projects, new conversation
  • Tasks -- view, create, edit, run, pause/resume, delete cron jobs; run history; completion alerts; a Scripts subtab for a read-only browse of the profile's ~/.hermes/scripts/ directory (see docs/scripts-panel.md)
  • Skills -- list all skills by category, search, preview, create/edit/delete; linked files viewer
  • Memory -- view and edit MEMORY.md and USER.md inline
  • Profiles -- create, switch, delete agent profiles; clone config
  • Todos -- live task list from the current session; hidden while the in-chat task list toggle is on, which also disables the workspace-panel Todos tab
  • Insights -- token, cost, and skill-usage analytics; period presets (7/30/90/365 days) plus a Custom range with start/end date pickers
  • Artifacts -- files changed in the session and Skills Used, with a separate skill count and per-skill use counts
  • Spaces -- add, rename, remove workspaces; quick-switch from topbar

Mobile responsive

  • Hamburger sidebar -- slide-in overlay on mobile (<640px)
  • Sidebar top tabs stay available on mobile; no fixed bottom nav stealing chat height
  • Files slide-over panel from right edge
  • Touch targets minimum 44px on all interactive elements
  • Full-height chat/composer on phones without bottom-nav spacing
  • Desktop layout completely unchanged

Configuration & access

start.sh auto-detects almost everything; the subsections below cover the knobs for when it can't, and how to reach the UI remotely.

What start.sh discovers automatically

Thing How it finds it
Hermes agent dir HERMES_WEBUI_AGENT_DIR, then valid authoritative run_agent.py checkouts, the hermes launcher, the selected Python, valid fallback checkouts, and finally marker-only roots
Python executable HERMES_WEBUI_PYTHON, Agent venv, interpreter that proved the Agent root, .venv in this repo, then system Python
State directory HERMES_WEBUI_STATE_DIR env, then $HERMES_HOME/webui (Windows default %LOCALAPPDATA%\hermes\webui, POSIX default ~/.hermes/webui)
Default workspace HERMES_WEBUI_DEFAULT_WORKSPACE env, then ~/workspace, then state dir
Port HERMES_WEBUI_PORT env or first argument, default 8787

Before it installs the agent or writes any state, the bootstrap binds the resolved host and port as a preflight. If another service already holds the port, it stops right there, names the address it could not bind, and prints a free alternative to pass to ./start.sh <port> or set as HERMES_WEBUI_PORT in .env. The running service and your existing configuration are left untouched. When the listener on that port is a healthy WebUI -- the instance you already started -- bootstrap reports it ready and leaves it alone, browser included; only a foreign service gets the conflict message.

If discovery finds everything, nothing else is required.


Overrides (only needed if auto-detection misses)

export HERMES_WEBUI_AGENT_DIR=/path/to/hermes-agent
export HERMES_WEBUI_PYTHON=/path/to/python
export HERMES_WEBUI_PORT=9000
export HERMES_WEBUI_AUTO_INSTALL=1  # enable auto-install of agent deps (disabled by default)
./start.sh

Auto-install requires the selected Agent to match HERMES_WEBUI_AGENT_DIR or the Agent under HERMES_HOME, and still checks ownership and permissions.

Or inline:

HERMES_WEBUI_AGENT_DIR=/custom/path ./start.sh 9000

Full list of environment variables:

Variable Default Description
HERMES_WEBUI_AGENT_DIR auto-discovered Path to the Hermes Agent source or installed module root
HERMES_WEBUI_PYTHON auto-discovered Python executable
HERMES_WEBUI_HOST 127.0.0.1 Bind address (0.0.0.0 for all IPv4, :: for all IPv6, ::1 for IPv6 loopback)
HERMES_WEBUI_PORT 8787 Port
HERMES_WEBUI_STATE_DIR $HERMES_HOME/webui (Windows default %LOCALAPPDATA%\hermes\webui, POSIX default ~/.hermes/webui) Where sessions and state are stored. Note (upgrade): the default now follows HERMES_HOME — if you previously relocated HERMES_HOME to a non-default base without setting HERMES_WEBUI_STATE_DIR, your WebUI state now resolves to $HERMES_HOME/webui instead of the old platform-default ~/.hermes/webui. To keep using the old location, set HERMES_WEBUI_STATE_DIR to it (or move the directory). Installs with HERMES_HOME unset or at the default base are unaffected.
HERMES_WEBUI_SETTINGS_FILE <state dir>/settings.json Optional path for this instance's WebUI settings file (sessions, workspaces and projects stay in the state directory). Read once at startup, so restart after changing it
HERMES_WEBUI_DEFAULT_WORKSPACE ~/workspace Default workspace
HERMES_WEBUI_DEFAULT_MODEL (provider default) Optional model override; leave unset to use the active Hermes provider default
HERMES_WEBUI_PASSWORD (unset) Set to enable password authentication
HERMES_WEBUI_CSP_CONNECT_EXTRA (unset) Optional space-separated http(s):// or ws(s):// origins to append to the enforced and report-only CSP connect-src directives for trusted reverse-proxy, tunnel, or extension sidecar deployments
HERMES_WEBUI_CSP_IMG_EXTRA (unset) Optional space-separated http(s):// image origins (wildcard subdomain and port allowed), or the bare https: / http: scheme, added to the CSP img-src. Remote images are blocked by default so an assistant reply cannot make the browser fetch an arbitrary URL; blocked images render as an inert "Open image" link. Use this to show images from a trusted CDN inline, e.g. an image-generation provider
HERMES_WEBUI_SSE_CHUNKED (unset) Set truthy (1/true/yes/on) to send SSE with Transfer-Encoding: chunked. Needed behind buffering reverse proxies (e.g. jupyter-server-proxy) that otherwise buffer the whole stream; harmless but unnecessary for directly-served deployments
HERMES_WEBUI_EXTENSION_DIR (unset) Optional local directory served at /extensions/; must point to an existing directory before extension injection is enabled
HERMES_WEBUI_EXTENSION_MANIFEST (unset) Optional relative JSON manifest inside HERMES_WEBUI_EXTENSION_DIR listing bundled scripts/styles to inject; see WebUI Extensions
HERMES_WEBUI_EXTENSION_SCRIPT_URLS (unset) Optional comma-separated same-origin script URLs to inject; appended after manifest scripts; see WebUI Extensions
HERMES_WEBUI_EXTENSION_STYLESHEET_URLS (unset) Optional comma-separated same-origin stylesheet URLs to inject; appended after manifest stylesheets; see WebUI Extensions
HERMES_HOME Windows: %LOCALAPPDATA%\hermes; POSIX: ~/.hermes Base directory for Hermes state (affects all paths)
HERMES_CONFIG_PATH $HERMES_HOME/config.yaml Path to Hermes config file
HERMES_WEBUI_SERVER_CWD (unset) Working directory for the server process. Defaults to the agent dir; point it at a writable workspace when the agent dir is read-only so fallback relative writes land somewhere writable
HERMES_WEBUI_VISIBLE_SESSION_LIMIT 20 Size of the sidebar's interactive recency window (how many recent non-cron/webhook sessions are listed). Also bounds how many delegated subagent children can nest at once, since a child only renders when its row wins a slot in the window — raise it for wide fan-outs. Non-integer or non-positive values fall back to the default. Values above 200 are clamped. Resolved before profile init, so a profile .env cannot override it
HERMES_WEBUI_AGENT_CACHE_MAX 25 Max live agent instances kept warm in the in-memory LRU. Each pins a full conversation transcript, so this is the dominant lever on resident memory — lower it on installs with many long sessions to cap RAM (at the cost of more cold reloads)
HERMES_WEBUI_SESSIONS_MAX 100 Legacy operator override for the max compact Session objects held in the in-memory LRU. Prefer the webui.sessions_cache_max key in config.yaml (which takes precedence); this env var remains a fallback. Bounds resident memory so long-running installs cannot accumulate every session ever touched and eventually crash (#4765/#2233/#4633). Eviction only ever drops clean, persisted, non-active sessions; an evicted session lazily reloads from its JSON sidecar on next access
HERMES_WEBUI_RUN_JOURNAL_SWEEP (unset) Set to 0/false/off to disable the run-journal retention sweep entirely (#7613)
HERMES_WEBUI_RUN_JOURNAL_RETENTION_TTL_DAYS 14 Runs whose journal file is older than N days are archived (compressed into _run_journal_archive/, not deleted). 0 disables the age cap. Also settable via run_journal_retention_ttl_days in settings.json (the env var wins)
HERMES_WEBUI_RUN_JOURNAL_RETENTION_MAX_RUNS_PER_SESSION 40 Keep at most N newest runs live per session; older runs are archived. 0 disables the count cap (run_journal_retention_max_runs_per_session in settings.json)
HERMES_WEBUI_RUN_JOURNAL_RETENTION_MAX_BYTES_PER_SESSION 268435456 (256 MiB) Per-session budget for LIVE run-journal bytes; sessions over budget archive their oldest runs. 0 disables the size cap (run_journal_retention_max_bytes_per_session in settings.json)
HERMES_WEBUI_RUN_JOURNAL_ARCHIVE_TTL_DAYS 0 (keep forever) The only destructive knob: archives older than N days are deleted, except an archive a session still needs to recover an interrupted answer, which is kept until the session no longer references it or is deleted. 0 (default) never deletes archives — a stock install keeps every archived run forever (run_journal_archive_ttl_days in settings.json)
Run-journal retention (#7613)

The run journal stores one {run_id}.jsonl per run under sessions/_run_journal/<session_id>/; nothing removed them, so a long-lived session's journal grew without bound. An hourly sweep (piggybacked on the existing maintenance tick, never on a request path) now archives runs past the caps above rather than deleting them:

  • eligible runs are compressed (gzip) into sessions/_run_journal_archive/<session_id>/<run_id>.jsonl.gz — measured at 5–18% of the original size on real journals;
  • the compressed copy is verified to decompress to the exact original bytes before the live file is dropped;
  • runs that have not provably settled (no complete terminal row — including a journal truncated mid-write) are never touched;
  • a run the session still needs to recover an interrupted answer (its active stream, or the run an interrupted-turn marker names) stays live, so a release that predates the archive format can still recover it after a rollback;
  • every read path (run summaries, event reads, session replay, run lookup) transparently falls back to the archive, so a wrong classification costs one compressed copy, not the run;
  • deleting a session deletes its archives too.

Where dir_fd primitives are unavailable (Windows), the sweep disables itself rather than fall back to path-based moves a directory swap could redirect.

Extension deployments can inspect sanitized, authenticated diagnostics at GET /api/extensions/status; see WebUI Extensions.


Nix flake and NixOS module

Hermes WebUI has a Nix flake package and a NixOS service module so you can run it declaratively.

Install the latest package with:

nix shell github:nesquena/hermes-webui#default

Use this flake input in your system configuration:

inputs.hermes-webui.url = "github:nesquena/hermes-webui";

Then add the module and configure it in nixosModules:

{
  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
    hermes-agent.url = "github:NousResearch/hermes-agent";
    hermes-webui.url = "github:nesquena/hermes-webui";
  };

  outputs = { self, nixpkgs, hermes-agent, hermes-webui, ... }: {
    nixosConfigurations.<host> = nixpkgs.lib.nixosSystem {
      modules = [
        hermes-agent.nixosModules.default
        hermes-webui.nixosModules.default
        ({ pkgs, ... }: {
          services.hermes-agent.enable = true;
          services.hermes-webui = {
            enable = true;
            host = "127.0.0.1";
            port = 8787;
            stateDir = "/var/lib/hermes-webui";
            user = "hermes";
            group = "hermes";
            hermesHome = "/var/lib/hermes/.hermes";
            agent.package = hermes-agent.packages.${pkgs.stdenv.hostPlatform.system}.default;
            environmentFiles = [ "/run/secrets/hermes-webui.env" ];
          };
        })
      ];
    };
  };
}

The module defaults to 127.0.0.1. Set host = "0.0.0.0" and openFirewall = true only when you want direct network access, and pair that with auth, for example HERMES_WEBUI_PASSWORD via environmentFiles.

The published Hermes Agent package exposes passthru.hermesVenv, so the module derives HERMES_WEBUI_PYTHON from its interpreter. Bootstrap then locates the installed run_agent.py through that interpreter without importing Agent code and exports its parent as HERMES_WEBUI_AGENT_DIR. Packages may expose passthru.hermesAgentDir as a direct path instead. Use agent.dir and agent.python as explicit overrides for custom package layouts.

When WebUI reads shared Hermes Agent state, run the service as a user that can already read that state. For a co-located Hermes Agent service, set user and group to the agent service account; the module only creates the default hermes-webui account and never changes ownership of an existing hermesHome.

The module maps directly onto existing WebUI environment variables, including: HERMES_WEBUI_HOST, HERMES_WEBUI_PORT, HERMES_WEBUI_STATE_DIR, HERMES_HOME, HERMES_WEBUI_AGENT_DIR, and HERMES_WEBUI_PYTHON.

Set environmentFiles for secrets like API keys. Protected WebUI runtime keys from the module are rejected there, so keep host, port, state, and agent wiring in the module options. Keep reverse proxy and TLS configuration in your surrounding deployment module because those details are deployment-specific.

Remote access (SSH tunnel, Tailscale, phone)

The server binds to 127.0.0.1 by default. To reach it from another machine, use an SSH tunnel (ssh -N -L 8787:127.0.0.1:8787 user@host, which start.sh prints for you over SSH) or, on a single-operator or access-restricted tailnet, use the preferred Tailscale Serve flow, which keeps WebUI on loopback behind tailnet-only HTTPS. Direct access to http://<server-tailscale-ip>:8787 with HERMES_WEBUI_HOST=0.0.0.0 and HERMES_WEBUI_PASSWORD is a fallback when Serve is unavailable. Full setup and the community ARM64-Android field report: docs/remote-access.md.

Manual launch (without start.sh)

If you prefer to launch the server directly (for example from your own systemd unit):

export HERMES_WEBUI_AGENT_DIR=/path/to/hermes-agent   # optional, see below
HERMES_WEBUI_PORT=8787 python3 /path/to/hermes-webui/server.py

Before importing anything else, server.py activates the Hermes Agent's dependency environment. It uses HERMES_WEBUI_AGENT_DIR when set, otherwise the same discovery start.sh uses ($HERMES_HOME/hermes-agent, ~/.hermes/hermes-agent, the hermes launcher, …), so the export is only needed for an Agent installed somewhere else. A Hermes-managed Agent (v0.21.6 or newer, installed by the official installer or hermes update) then restarts the server in its own Python with its own dependencies, so the interpreter you launch with does not need the Agent's packages. An older Agent that keeps its dependencies in venv/ or .venv/ is not restarted: run server.py with that venv's Python instead (/path/to/hermes-agent/venv/bin/python). System Python on its own lacks openai, httpx and other required packages.

Health check:

curl http://127.0.0.1:8787/health

Docker

Pre-built images (amd64 + arm64) are published to GHCR on every release.

For a comprehensive setup guide covering all 3 compose files, common failure modes, and bind-mount migration, see docs/docker.md. The README covers the 5-minute happy path.

5-minute quickstart (single container)

The simplest setup: one WebUI container that runs the agent in-process.

git clone https://github.com/nesquena/hermes-webui
cd hermes-webui
cp .env.docker.example .env
# Edit .env if your host UID isn't 1000 (e.g. macOS where UIDs start at 501)
docker compose up -d
# Open http://localhost:8787

Run Compose as the user who owns your Hermes home. sudo docker compose up -d can make ${HOME} expand to the root user's home, so Docker mounts the wrong .hermes directory instead of your real ~/.hermes and the WebUI starts with config.yaml (not found, using defaults). Prefer adding your user to the Docker group and running docker compose up -d; if you must use sudo, set absolute paths first, for example HERMES_HOME=/home/you/.hermes HERMES_WORKSPACE=/home/you/workspace sudo -E docker compose up -d, then verify with docker compose config.

The container auto-detects your UID/GID from the mounted ~/.hermes volume so files written by the agent stay readable by you on the host.

To enable password protection (required if you expose the port outside 127.0.0.1):

echo "HERMES_WEBUI_PASSWORD=change-me-to-something-strong" >> .env
docker compose up -d --force-recreate

Manual docker run (no compose)

docker pull ghcr.io/nesquena/hermes-webui:latest
docker run -d \
  -e WANTED_UID=$(id -u) -e WANTED_GID=$(id -g) \
  -v ~/.hermes:/home/hermeswebui/.hermes \
  -e HERMES_WEBUI_STATE_DIR=/home/hermeswebui/.hermes/webui \
  -v ~/workspace:/workspace \
  -p 127.0.0.1:8787:8787 \
  ghcr.io/nesquena/hermes-webui:latest

Build locally

docker build -t hermes-webui .
docker run -d \
  -e WANTED_UID=$(id -u) -e WANTED_GID=$(id -g) \
  -v ~/.hermes:/home/hermeswebui/.hermes \
  -e HERMES_WEBUI_STATE_DIR=/home/hermeswebui/.hermes/webui \
  -v ~/workspace:/workspace \
  -p 127.0.0.1:8787:8787 \
  hermes-webui

Multi-container setups

If you want the agent and WebUI in separate containers (for isolation, or because you're already running an agent gateway elsewhere):

# Agent + WebUI
docker compose -f docker-compose.two-container.yml up -d

# Agent + Dashboard + WebUI
docker compose -f docker-compose.three-container.yml up -d

Both compose files use named Docker volumes by default, which solves the UID/GID problem by construction. If you need bind mounts to share an existing host directory, see docs/docker.md for the full migration recipe.

Known limitation (#681): in the two-container setup, tools triggered from the WebUI run in the WebUI container, not the agent container. If you need git/node/etc. on the WebUI's filesystem, either use the single-container setup, extend the WebUI Dockerfile, or use the community all-in-one image.

Source boundary note (#2453): the multi-container setup mounts hermes-agent-src read-only into the WebUI by default. This prevents WebUI-side source rewrites but is still an implementation-coupling bridge, not a stable Agent API boundary. See docs/rfcs/agent-source-boundary.md for the current source/API decoupling inventory.

Common failure modes

Symptom Likely cause Fix
PermissionError at startup UID mismatch on bind mount Set UID=$(id -u) in .env
.env: permission denied (#1389) fix_credential_permissions() enforced 0600 Set HERMES_SKIP_CHMOD=1 in .env
Workspace appears empty UID mismatch on /workspace mount Set UID=$(id -u) in .env
git: command not found in chat Two-container architectural limit (#681) Use single-container or extend Dockerfile
WebUI can't find agent source hermes-agent-src volume misconfigured Use the named volumes from compose files as-is
Podman shared .hermes fails Podman 3.4 keep-id limitation Use Podman 4+ or single-container
Host API at localhost fails from WebUI Container localhost means the container, not your host (#3012) Use http://host.docker.internal:<port> on Docker Desktop, or http://host.containers.internal:<port> on Podman
WebUI can't see ~/.hermes after sudo docker compose ${HOME} expanded to the root user's home (#3006) Run Compose as your user, or pass absolute HERMES_HOME/HERMES_WORKSPACE with sudo -E

For the deep dive on each of these, see docs/docker.md.

Note: By default, Docker Compose binds to 127.0.0.1 (localhost only). To expose on a network, change the port to "8787:8787" in docker-compose.yml and set HERMES_WEBUI_PASSWORD to enable authentication.


Running tests

Tests discover the repo and the Hermes agent dynamically -- no hardcoded paths. Use the repo test runner so local runs do not accidentally use an unsupported system Python. It creates/uses .venv with Python 3.11, 3.12, or 3.13 and installs the dev test dependencies from requirements-dev.txt when missing.

cd hermes-webui
./scripts/test.sh

Pass normal pytest arguments after the script for focused runs:

./scripts/test.sh tests/test_regressions.py -v

Or seed the repo .venv from an explicit supported base interpreter:

HERMES_WEBUI_TEST_PYTHON=/path/to/python3.12 ./scripts/test.sh tests/ -v

The override selects the Python used to create or rebuild .venv; dependencies are still installed into the repo-local virtual environment, not into the system/Homebrew interpreter.

Tests run against an isolated server with a separate state directory. Production data and real cron jobs are never touched. Current snapshot: ~11,500 tests collected across ~1,150 test files, run in CI on Python 3.11, 3.12, and 3.13 (3 parallel shards each).


Architecture

No build step, no framework, no bundler — a Python standard-library HTTP server and vanilla JS. The backend lives in api/, the frontend in static/.

Backend (api/)

server.py         HTTP routing shell + auth middleware
api/
  auth.py         Optional password authentication, signed cookies, passkeys
  config.py       Discovery, globals, model detection, reloadable config
  helpers.py      HTTP helpers, security headers
  models.py       Session model + CRUD + CLI/state.db bridge
  onboarding.py   First-run onboarding wizard, OAuth provider support
  profiles.py     Profile state management, hermes_cli wrapper
  routes.py       All GET + POST route handlers (if/elif dispatch, no decorators)
  state_sync.py   /insights sync — message_count to state.db
  streaming.py    SSE engine, run_agent, cancellation, compression
  updates.py      Self-update check and release notes
  upload.py       Multipart parser, file upload handler
  workspace.py    File ops, workspace helpers, git detection

Frontend (static/)

index.html        HTML template
style.css         All CSS incl. mobile responsive, themes + skins
ui.js             DOM helpers, renderMd, tool cards, context indicator
workspace.js      File preview, file ops, git badge, central api() fetch wrapper
sessions.js       Session CRUD, collapsible groups, search, reload recovery
messages.js       send(), SSE handlers, live streaming, session recovery
panels.js         Cron, skills, memory, profiles, settings (Control Center)
commands.js       Slash command autocomplete
boot.js           Mobile nav, voice input, theme/skin boot, bfcache handler

Tests + packaging

tests/            Pytest suite (~11,500 tests; isolated server/state fixtures)
pyproject.toml    Standard build metadata plus the Ruff lint gate; checkout launch surface still centers on bootstrap.py / start.sh / ctl.sh
Dockerfile        python:3.12-slim container image
docker-compose.yml  Compose with named volume and optional auth
.github/workflows/  CI: ruff + sharded pytest, browser smoke, Docker smoke,
                    multi-arch Docker build + GitHub Release on tag

State lives outside the repo at ~/.hermes/webui/ by default (sessions, workspaces, settings, projects, last_workspace). Override with HERMES_WEBUI_STATE_DIR. Full design notes and the endpoint catalog are in ARCHITECTURE.md.


Compatibility

The version shown in the WebUI runtime status is the WebUI version only (build/image/tag currently running). It is not a full compatibility map.

The WebUI is still coupled to Hermes Agent internals for runtime execution, provider/model access, and state/schema usage until the stable agent boundary work in

Recent activity

commits and pull requests

Releases and announcements

1,000 total
  1. exp-v0.52.677exp-v0.52.677Nov 12, 2026pre-release

    ## What's Changed * Release exp-v0.52.677: event-driven sidebar refreshes are throttled, and session-list builds are certified against the pre-build stamp (#8986, finishing #8694) by @nesquena-hermes in https://github.com/nesquena/hermes-webui/pull/8988 * perf(sessions): throttle event-driven sidebar refreshes (maintainer finish of #8694) by @nesquena-hermes in https://github.com/nesquena/hermes-webui/pull/8986 **Full Changelog**: https://github.com/nesquena/hermes-webui/compare/exp-v0.52.676...exp-v0.52.677

  2. exp-v0.52.676exp-v0.52.676Nov 12, 2026pre-release

    ## What's Changed * Release exp-v0.52.676: a sidebar poll can no longer save an older copy of a session over a newer turn (#9028) by @nesquena-hermes in https://github.com/nesquena/hermes-webui/pull/9034 **Known limit:** when the stale-stream cleanup skips its save because the session changed, its reloaded copy stays in memory, and the next sidebar build can still save that older copy over the newer turn. Before this release the loss happened on the first poll; now it happens one poll later. The fix is tracked in #9017. **Full Changelog**: https://github.com/nesquena/hermes-webui/compare/exp-v0.52.675...exp-v0.52.676

  3. exp-v0.52.675exp-v0.52.675Nov 12, 2026pre-release

    ## What's Changed * release: #8949 helpers that reload a session by id refuse a copy-loaded session object (#8949) by @nesquena-hermes in https://github.com/nesquena/hermes-webui/pull/8995 * fix(sessions): refuse a copy in the helpers that reload by session id (#8869) by @Lil-Clanky in https://github.com/nesquena/hermes-webui/pull/8949 ## New Contributors * @Lil-Clanky made their first contribution in https://github.com/nesquena/hermes-webui/pull/8949 **Full Changelog**: https://github.com/nesquena/hermes-webui/compare/exp-v0.52.674...exp-v0.52.675

  4. exp-v0.52.674exp-v0.52.674Nov 11, 2026pre-release

    ## What's Changed * Release exp-v0.52.674: listing sessions never saves one, so another profile's sidebar poll can't overwrite a newer turn (#9023) by @nesquena-hermes in https://github.com/nesquena/hermes-webui/pull/9025 * fix(sessions): a session listing never saves, so another profile's poll can't overwrite a newer turn (#9007) by @nesquena-hermes in https://github.com/nesquena/hermes-webui/pull/9023 **Full Changelog**: https://github.com/nesquena/hermes-webui/compare/exp-v0.52.673...exp-v0.52.674

  5. exp-v0.52.673exp-v0.52.673Nov 11, 2026pre-release

    ## What's Changed * release: #9015 tests restore config's disk-load state after every test by @nesquena-hermes in https://github.com/nesquena/hermes-webui/pull/9018 * test: restore config's disk-load state after every test by @nesquena in https://github.com/nesquena/hermes-webui/pull/9015 * test(uploads): pin that one visible stored copy leaves an upload to the load (#8855 follow-up) by @nesquena-hermes in https://github.com/nesquena/hermes-webui/pull/9021 * test(providers): the #3260 provider-settings tests stop leaking config and env into later tests (#9020) by @nesquena-hermes in https://github.com/nesquena/hermes-webui/pull/9022 **Full Changelog**: https://github.com/nesquena/hermes-webui/compare/exp-v0.52.672...exp-v0.52.673

Code frequency

additions and deletions
+60.1K-60.1KWeek of 2026-03-29: +25,812 linesWeek of 2026-03-29: -3,933 linesWeek of 2026-04-05: +9,980 linesWeek of 2026-04-05: -1,343 linesWeek of 2026-04-12: +30,085 linesWeek of 2026-04-12: -6,095 linesWeek of 2026-04-19: +31,259 linesWeek of 2026-04-19: -3,976 linesWeek of 2026-04-26: +55,010 linesWeek of 2026-04-26: -10,242 linesWeek of 2026-05-03: +57,158 linesWeek of 2026-05-03: -5,728 linesWeek of 2026-05-10: +41,510 linesWeek of 2026-05-10: -6,428 linesWeek of 2026-05-17: +33,141 linesWeek of 2026-05-17: -3,747 linesWeek of 2026-05-24: +25,652 linesWeek of 2026-05-24: -3,591 linesWeek of 2026-05-31: +48,295 linesWeek of 2026-05-31: -6,759 linesWeek of 2026-06-07: +41,856 linesWeek of 2026-06-07: -3,427 linesWeek of 2026-06-14: +52,467 linesWeek of 2026-06-14: -5,519 linesWeek of 2026-06-21: +59,919 linesWeek of 2026-06-21: -5,933 linesWeek of 2026-06-28: +60,145 linesWeek of 2026-06-28: -7,040 linesWeek of 2026-07-05: +49,299 linesWeek of 2026-07-05: -4,089 linesWeek of 2026-07-12: +26,469 linesWeek of 2026-07-12: -2,872 linesWeek of 2026-07-19: +18,802 linesWeek of 2026-07-19: -1,567 linesWeek of 2026-07-26: +6,436 linesWeek of 2026-07-26: -1,298 linesWeek of 2026-08-02: +8,353 linesWeek of 2026-08-02: -874 linesWeek of 2026-08-09: +21,977 linesWeek of 2026-08-09: -1,613 linesWeek of 2026-08-16: +25,823 linesWeek of 2026-08-16: -1,779 linesWeek of 2026-08-23: +6,293 linesWeek of 2026-08-23: -840 linesWeek of 2026-08-30: +2,403 linesWeek of 2026-08-30: -456 linesWeek of 2026-09-06: +8,878 linesWeek of 2026-09-06: -1,257 linesWeek of 2026-09-13: +24,688 linesWeek of 2026-09-13: -2,009 linesWeek of 2026-09-20: +23,413 linesWeek of 2026-09-20: -3,378 linesMar 29, 2026Sep 20, 2026
+795.1K lines added, -95.8K removed over the last year.

Commits per week

last 52 weeks
9720Week of 2025-11-16: 0 commitsWeek of 2025-11-23: 0 commitsWeek of 2025-11-30: 0 commitsWeek of 2025-12-07: 0 commitsWeek of 2025-12-14: 0 commitsWeek of 2025-12-21: 0 commitsWeek of 2025-12-28: 0 commitsWeek of 2026-01-04: 0 commitsWeek of 2026-01-11: 0 commitsWeek of 2026-01-18: 0 commitsWeek of 2026-01-25: 0 commitsWeek of 2026-02-01: 0 commitsWeek of 2026-02-08: 0 commitsWeek of 2026-02-15: 0 commitsWeek of 2026-02-22: 0 commitsWeek of 2026-03-01: 0 commitsWeek of 2026-03-08: 0 commitsWeek of 2026-03-15: 0 commitsWeek of 2026-03-22: 0 commitsWeek of 2026-03-29: 294 commitsWeek of 2026-04-05: 218 commitsWeek of 2026-04-12: 299 commitsWeek of 2026-04-19: 243 commitsWeek of 2026-04-26: 265 commitsWeek of 2026-05-03: 476 commitsWeek of 2026-05-10: 388 commitsWeek of 2026-05-17: 270 commitsWeek of 2026-05-24: 270 commitsWeek of 2026-05-31: 315 commitsWeek of 2026-06-07: 277 commitsWeek of 2026-06-14: 449 commitsWeek of 2026-06-21: 736 commitsWeek of 2026-06-28: 972 commitsWeek of 2026-07-05: 527 commitsWeek of 2026-07-12: 197 commitsWeek of 2026-07-19: 127 commitsWeek of 2026-07-26: 92 commitsWeek of 2026-08-02: 121 commitsWeek of 2026-08-09: 220 commitsWeek of 2026-08-16: 152 commitsWeek of 2026-08-23: 127 commitsWeek of 2026-08-30: 59 commitsWeek of 2026-09-06: 143 commitsWeek of 2026-09-13: 201 commitsWeek of 2026-09-20: 503 commitsWeek of 2026-09-27: 340 commitsWeek of 2026-10-04: 758 commitsWeek of 2026-10-11: 611 commitsWeek of 2026-10-18: 504 commitsWeek of 2026-10-25: 622 commitsWeek of 2026-11-01: 452 commitsWeek of 2026-11-08: 188 commitsNov 16, 2025Nov 8, 2026
11.4K commits in the last 52 weeks.

When work happens

weekday and hour
SunMonTueWedThuFriSat036912151821Sun 0:00 — 44 commitsSun 1:00 — 29 commitsSun 2:00 — 44 commitsSun 3:00 — 35 commitsSun 4:00 — 43 commitsSun 5:00 — 39 commitsSun 6:00 — 32 commitsSun 7:00 — 27 commitsSun 8:00 — 31 commitsSun 9:00 — 30 commitsSun 10:00 — 53 commitsSun 11:00 — 33 commitsSun 12:00 — 38 commitsSun 13:00 — 34 commitsSun 14:00 — 46 commitsSun 15:00 — 50 commitsSun 16:00 — 54 commitsSun 17:00 — 69 commitsSun 18:00 — 73 commitsSun 19:00 — 61 commitsSun 20:00 — 52 commitsSun 21:00 — 44 commitsSun 22:00 — 44 commitsSun 23:00 — 52 commitsMon 0:00 — 48 commitsMon 1:00 — 49 commitsMon 2:00 — 39 commitsMon 3:00 — 25 commitsMon 4:00 — 21 commitsMon 5:00 — 32 commitsMon 6:00 — 30 commitsMon 7:00 — 29 commitsMon 8:00 — 41 commitsMon 9:00 — 29 commitsMon 10:00 — 59 commitsMon 11:00 — 50 commitsMon 12:00 — 42 commitsMon 13:00 — 37 commitsMon 14:00 — 54 commitsMon 15:00 — 52 commitsMon 16:00 — 66 commitsMon 17:00 — 94 commitsMon 18:00 — 68 commitsMon 19:00 — 58 commitsMon 20:00 — 58 commitsMon 21:00 — 65 commitsMon 22:00 — 65 commitsMon 23:00 — 62 commitsTue 0:00 — 48 commitsTue 1:00 — 39 commitsTue 2:00 — 51 commitsTue 3:00 — 62 commitsTue 4:00 — 38 commitsTue 5:00 — 37 commitsTue 6:00 — 34 commitsTue 7:00 — 35 commitsTue 8:00 — 40 commitsTue 9:00 — 39 commitsTue 10:00 — 57 commitsTue 11:00 — 48 commitsTue 12:00 — 49 commitsTue 13:00 — 54 commitsTue 14:00 — 53 commitsTue 15:00 — 40 commitsTue 16:00 — 69 commitsTue 17:00 — 78 commitsTue 18:00 — 75 commitsTue 19:00 — 74 commitsTue 20:00 — 75 commitsTue 21:00 — 78 commitsTue 22:00 — 89 commitsTue 23:00 — 63 commitsWed 0:00 — 54 commitsWed 1:00 — 43 commitsWed 2:00 — 44 commitsWed 3:00 — 24 commitsWed 4:00 — 32 commitsWed 5:00 — 29 commitsWed 6:00 — 32 commitsWed 7:00 — 51 commitsWed 8:00 — 57 commitsWed 9:00 — 85 commitsWed 10:00 — 71 commitsWed 11:00 — 50 commitsWed 12:00 — 30 commitsWed 13:00 — 38 commitsWed 14:00 — 45 commitsWed 15:00 — 72 commitsWed 16:00 — 65 commitsWed 17:00 — 54 commitsWed 18:00 — 63 commitsWed 19:00 — 72 commitsWed 20:00 — 93 commitsWed 21:00 — 51 commitsWed 22:00 — 77 commitsWed 23:00 — 84 commitsThu 0:00 — 88 commitsThu 1:00 — 63 commitsThu 2:00 — 68 commitsThu 3:00 — 59 commitsThu 4:00 — 46 commitsThu 5:00 — 39 commitsThu 6:00 — 41 commitsThu 7:00 — 37 commitsThu 8:00 — 42 commitsThu 9:00 — 47 commitsThu 10:00 — 42 commitsThu 11:00 — 48 commitsThu 12:00 — 39 commitsThu 13:00 — 35 commitsThu 14:00 — 46 commitsThu 15:00 — 70 commitsThu 16:00 — 83 commitsThu 17:00 — 75 commitsThu 18:00 — 80 commitsThu 19:00 — 88 commitsThu 20:00 — 74 commitsThu 21:00 — 77 commitsThu 22:00 — 98 commitsThu 23:00 — 59 commitsFri 0:00 — 65 commitsFri 1:00 — 47 commitsFri 2:00 — 31 commitsFri 3:00 — 44 commitsFri 4:00 — 29 commitsFri 5:00 — 37 commitsFri 6:00 — 28 commitsFri 7:00 — 49 commitsFri 8:00 — 53 commitsFri 9:00 — 64 commitsFri 10:00 — 50 commitsFri 11:00 — 81 commitsFri 12:00 — 67 commitsFri 13:00 — 76 commitsFri 14:00 — 27 commitsFri 15:00 — 48 commitsFri 16:00 — 75 commitsFri 17:00 — 49 commitsFri 18:00 — 55 commitsFri 19:00 — 74 commitsFri 20:00 — 86 commitsFri 21:00 — 45 commitsFri 22:00 — 105 commitsFri 23:00 — 72 commitsSat 0:00 — 57 commitsSat 1:00 — 53 commitsSat 2:00 — 45 commitsSat 3:00 — 56 commitsSat 4:00 — 61 commitsSat 5:00 — 42 commitsSat 6:00 — 44 commitsSat 7:00 — 34 commitsSat 8:00 — 36 commitsSat 9:00 — 26 commitsSat 10:00 — 46 commitsSat 11:00 — 51 commitsSat 12:00 — 35 commitsSat 13:00 — 48 commitsSat 14:00 — 53 commitsSat 15:00 — 43 commitsSat 16:00 — 41 commitsSat 17:00 — 46 commitsSat 18:00 — 56 commitsSat 19:00 — 51 commitsSat 20:00 — 56 commitsSat 21:00 — 71 commitsSat 22:00 — 69 commitsSat 23:00 — 56 commits
Commit volume by weekday and hour (UTC). Larger dots mean more commits.

Who is committing

last 52 weeks
Maintainer commits337 (3%)
Community commits12,581 (97%)

12,918 commits in total over the last year.

DateListRankStars gained
Jun 3, 2026daily#20+26
Jun 2, 2026daily#9+40
Jun 1, 2026daily#11+46
May 31, 2026daily#24+58