Hermes Agent

Tool

Hermes Agent Dashboard: Setup, Security, and Localhost Troubleshooting

Community

Choose Hermes Dashboard on 9119 or the gateway Webapp on 9120. Verify browser chat, sign-in, remote access and profile boundaries before sharing your host.

Quick answer

Run hermes dashboard for browser administration and TUI-backed Chat, normally on 127.0.0.1:9119. For the Desktop-style browser workspace, use the gateway Webapp opened by hermes webapp, normally on port 9120. Both are self-hosted. Choose the surface first, then verify its sign-in, gateway, profile and a real response. Profiles and --isolated are not tenant-security boundaries.

Hermes has two different self-hosted browser surfaces: the administration Dashboard and the gateway-served Webapp workspace. The Dashboard includes real TUI Chat as well as configuration and monitoring; the Webapp brings the Desktop-style workspace to a browser. Your host still runs both. Use the comparison below before changing ports or credentials, and compare managed FlyHermes only when the goal is to hand off runtime operations.

Hermes Agent Web UI Dashboard – All Features Explained — BoxminingAI

Optional historical walkthrough by BoxminingAI showing launch, SSH access, Sessions, Analytics, Logs and configuration. UI details may differ from current builds; use the current official reference for authentication, host ownership and Chat lifecycle.

  • 0:00Introduction – live web dashboard overview
  • 0:47Launching: `hermes dashboard` and port 9119
  • 1:10VPS access via SSH tunnel (not direct link)
  • 2:30Sessions tab – chat and system cron messages
  • 4:10Analytics – API calls, token usage, per-model breakdown
  • 5:00Logs – debug failed cron jobs
  • 5:50Cron Jobs – create schedules and delivery targets
  • 7:40Skills – browse installed skills by category
  • 9:10Config – fallback providers, timeout, memory, routing, auxiliary
Diagram-style preview of the self-hosted Hermes Agent dashboard showing configuration, memory, skills, jobs, gateways, and status
Self-hosted WebUI administers your Hermes installation and includes terminal-backed Chat. FlyHermes is the separate managed option for browser/mobile access and connected channels without operating that installation.
Hermes Agent Web UI sessions dashboard showing connected platforms and recent sessions
Sessions view from the BoxminingAI walkthrough: recent sessions and system messages make WebUI useful for tracing what the agent actually did.
Hermes Agent Web UI logs dashboard showing cron and gateway error output
Logs view: use it for failed cron jobs, gateway errors, provider failures, and copyable debugging context before changing tokens or config.
Hermes Agent Web UI cron jobs dashboard for creating scheduled agent tasks
Cron Jobs view: create and inspect scheduled agent runs, then verify delivery in the real target channel.
Hermes Agent Web UI configuration dashboard with provider and runtime settings
Config view: WebUI is a self-hosted admin panel over Hermes settings; FlyHermes is the managed path when you do not want to own this surface.

Setup steps

  1. 1Run hermes doctor, then hermes dashboard --status to identify the backend owner before starting another server.
  2. 2Start locally with hermes dashboard; the default URL is http://127.0.0.1:9119.
  3. 3Use --port, --no-open, or --skip-build only for the specific port, headless, or prebuilt-frontend problem they solve.
  4. 4If startup exits 78 and names another backend, resolve that ownership conflict first. Do not treat another free port as a new independent installation.
  5. 5For a private VPS, keep the dashboard on loopback and use an SSH tunnel or VPN.
  6. 6Choose authentication for the exposure: built-in username/password only on trusted networks or VPNs; Nous OAuth or OIDC for public HTTPS. Verify signed-out management requests are denied before sharing the URL.
  7. 7Check the selected profile, sessions, analytics, logs, cron jobs, skills, MCP, config, and gateway state in that order.
  8. 8Finish with one real browser Chat response, Telegram/Discord message, or cron delivery; dashboard status alone is not end-to-end proof.

Command map

hermes doctor && hermes dashboard

Verify the installation and open the local dashboard on port 9119.

Fix CLI/provider/config failures before diagnosing Web UI.

systemctl --user status hermes-dashboard.service

Inspect the example Linux user service and its last exit status. Use the actual unit name if yours differs.

Exit 78 calls for resolving the named backend owner, not an infinite restart loop.

hermes dashboard --port 9120 --no-open

Choose another port and suppress browser launch on a server or SSH session.

A different port is not an access-control boundary.

ssh -N -o ExitOnForwardFailure=yes -L 127.0.0.1:19119:127.0.0.1:9119 user@your-vps

Run on the laptop, then open http://127.0.0.1:19119 there. Local 19119 forwards to server 9119 so a different laptop dashboard on 9119 is not mistaken for the remote host.

Start or reuse a loopback dashboard on the server first. Leave SSH connected. ExitOnForwardFailure detects forwarding setup failure, not remote dashboard health. This browser tunnel is not Desktop’s managed SSH registry connection.

hermes dashboard --status

List running dashboard processes before starting a duplicate server.

Dashboard process health does not prove gateway delivery.

hermes dashboard --stop

Stop running dashboard processes cleanly before changing bind, auth, or profile isolation.

This does not stop separately managed Telegram, Discord, or other gateway services.

hermes dashboard --isolated

Run a dedicated dashboard scoped to the named profile rather than the unified machine dashboard.

Use only when separate profile auth or network boundaries are intentional.

hermes dashboard register --name "My Hermes server"

Register a self-hosted dashboard with Nous Portal when you want the OAuth login gate.

A public deployment still needs HTTPS, firewalling, and a deliberate auth configuration.

HERMES_DASHBOARD_PUBLIC_URL=https://dashboard.example.com hermes dashboard --host 0.0.0.0 --port 9119 --no-open

Run an OAuth-registered dashboard behind Cloudflare Tunnel or another HTTPS reverse proxy with the correct callback authority.

Verify `/api/status` reports `auth_required: true`; Cloudflare Tunnel alone is not an authentication provider.

hermes pm repair

Repair damaged managed dependencies, then restart Hermes. Current standard PM setup includes the web stack; PTY helpers are core dependencies rather than a separate optional feature.

On native Windows, use WSL2 for the PTY-backed Chat tab.

hermes dashboard register --redirect-uri https://dashboard.example.com/auth/callback

Register the exact public HTTPS callback for Nous OAuth on the owning host; replace the example hostname and align HERMES_DASHBOARD_PUBLIC_URL.

Portal sign-in, callback completion and a valid dashboard session are separate checkpoints. Do not share full authorization URLs, codes or cookies.

Run the dashboard persistently on Linux

Use a systemd user service under the same Linux account that owns Hermes and can access Docker. This private-by-default unit keeps Web UI on loopback; use an SSH tunnel or VPN for remote browser access.

[Unit]
Description=Hermes Agent Web Dashboard
Wants=network-online.target
After=network-online.target

[Service]
Type=simple
WorkingDirectory=%h/.hermes/hermes-agent
EnvironmentFile=%h/.hermes/.env
Environment=PATH=%h/.local/bin:/usr/local/bin:/usr/bin:/bin
ExecStart=%h/.hermes/hermes-agent/venv/bin/python -m hermes_cli.main dashboard --host 127.0.0.1 --port 9119 --no-open --skip-build
Restart=on-failure
RestartSec=5
RestartPreventExitStatus=78

[Install]
WantedBy=default.target
  1. 1Before enabling this example, run hermes dashboard --status and identify any backend already serving the host. Do not install a second supervisor over it. The paths below are examples for a native Linux installation, not a Docker unit.
  2. 2Save the unit as ~/.config/systemd/user/hermes-dashboard.service. If Hermes or its virtual environment lives elsewhere, replace WorkingDirectory and ExecStart with the real paths.
  3. 3As the same Hermes user, run docker ps first if the agent uses the Docker terminal backend. Fix group/socket access before starting the service; do not run the dashboard as root as a workaround.
  4. 4Run systemctl --user daemon-reload && systemctl --user enable --now hermes-dashboard.service, then sudo loginctl enable-linger "$USER" if it must start at boot before login.
  5. 5Verify systemctl --user status hermes-dashboard.service, journalctl --user -u hermes-dashboard.service -n 100 --no-pager, and curl -s http://127.0.0.1:9119/api/status.
  6. 6Keep the messaging gateway independent with hermes gateway install and hermes gateway status, then prove one real channel delivery. Tunnel port 9119 for remote browser access instead of publishing the admin port.
  7. 7Exit 78 is a deliberate configuration refusal, not an ordinary crash. RestartPreventExitStatus=78 keeps systemd from retrying it forever. Read the journal for the named owner, decide which service should remain, and arrange a maintenance window before stopping an active backend. A different port alone does not resolve host ownership.

Self-hosted Web UI or FlyHermes?

Choose self-hosted Web UI

You want to own the runtime and inspect profiles, sessions, logs, schedules, tools, providers, and gateways inside a private admin boundary.

Avoid when: Your team wants managed browser/mobile access and always-on channels without server operations.

Choose the gateway Webapp

You want the Desktop-style sessions, files, Git, artifacts and terminal workspace in a browser while your gateway owns the runtime. Verify the installed version and Webapp sign-in first.

Avoid when: You only need admin controls, need an Electron-only capability, or cannot own the host and access policy. Webapp access can reach host commands and saved gateways.

Choose Desktop with a remote backend

You want the native project, files, terminal, artifacts, and Git workspace while an always-on machine owns the Hermes runtime.

Avoid when: You only need browser administration, or nobody wants to maintain the remote host, authentication, updates, and WebSocket path.

Choose FlyHermes

You want managed browser/mobile access, supported model API access, tooling infrastructure and core channels under the current plan. Compare the monthly usage allowance with one representative workflow.

Avoid when: Your workflow requires an unconfirmed private-network integration, custom runtime, export path or team access policy. Confirm those requirements before subscribing; managed does not mean unlimited or every integration included.

Before paying for managed access

Write down the exact task, connected account, required files, destination, approval step and expected weekly usage. Ask who handles a runtime outage and how you recover or export your work.

Avoid when: You have only tested a greeting. A successful demo does not establish tool permissions, background completion, retention terms or an SLA.

What you can verify

A service that refuses with exit 78 should remain stopped until the backend-owner conflict is resolved; a green process monitor is not the acceptance criterion.
A browser Chat check records the backend, profile, session ID, actual directory and harmless result. A green status card alone is insufficient.
A reconnect check verifies the same session and checks any side effect before retrying. It does not establish uninterrupted execution or exactly-once delivery.
The dashboard opens locally on 127.0.0.1:9119 and keeps data on the machine by default.
One machine dashboard can switch among profiles while gateway processes and profile session stores remain separately managed.
The Chat tab runs the real Hermes TUI behind an authenticated PTY/WebSocket rather than a separate lightweight chat implementation.
Non-loopback binds require a configured password or OAuth provider and fail closed when authentication is missing.
--insecure is deprecated and no longer disables authentication after the June 2026 hardening.
A real Telegram/Discord reply, cron delivery, or browser Chat response remains the final workflow proof.
Official dashboard docs confirm the browser Chat tab runs the real TUI with slash commands and approval prompts, while native Windows needs WSL2 for the PTY-backed Chat surface.

Features

  • ✓v0.20 Desktop artifacts, plugin SDK, quick entry, and multiple-window workflows remain distinct from the self-hosted Web UI control surface
  • ✓Machine-level profile switcher for Config, API Keys, Skills, MCP, Models, and Chat
  • ✓Status overview for version, gateways, active sessions, and recent sessions
  • ✓Sessions, analytics, token usage, logs, and resume controls
  • ✓Cron job creation, run state, schedules, and delivery inspection
  • ✓Skills, MCP catalog, tool selection, model, provider, and configuration management
  • ✓Browser Chat powered by the real Hermes TUI over an authenticated PTY/WebSocket
  • ✓Default localhost access on port 9119 with custom port and headless launch options
  • ✓Fail-closed authentication for non-loopback binds using password, Nous OAuth, or OIDC
  • ✓Unified machine dashboard by default, plus --isolated for intentional per-profile servers
  • ✓Remote Hermes Desktop backend support through hermes serve or the dashboard server
  • ✓Bot Mode boundary: Bots are isolated Hermes profiles, while the Bots roster, canonical chats, routines, and cross-machine connections live in Desktop
  • ✓Dashboard process controls with --status and --stop
  • ✓Clear boundary: self-hosted operations in Web UI; managed browser/mobile/channel uptime in FlyHermes
  • ✓Chats, Automation, and All session filters with exact-source filtering and FTS5 message search
  • ✓Resource-pressure warnings for low memory, suspected OOM restarts, and low disk space
  • ✓Browser management for channels, pairing, webhooks, system health, updates, and credentials
  • ✓Cron lifecycle inspection across scheduled, paused, completed, and blocked configuration states
  • ✓Run-history and delivery-error separation so operators do not rerun completed side effects
  • ✓Embedded TUI Chat with slash commands, model picker, tool-call cards, and clarify, sudo, and approval prompts
  • ✓Kanban board for watching tasks, dependencies, assignees, worker runs, and dispatcher state
  • ✓Dashboard themes and plugins for custom tabs, page slots, and authenticated backend endpoints
  • ✓Clear interface boundary: Desktop is chat-first and multi-connection; Web Dashboard is the browser admin/control plane

Why this tool matters

Backend ownership is separate from port availability. Current official docs describe exit 78 when an existing host-owning backend cannot satisfy the requested host/port. The persistent-service example therefore prevents automatic restart on that code. An intentional isolated profile server is different from accidentally running two supervisors over one backend.

For an internet-facing dashboard, choose Nous OAuth or a conformant OIDC provider. The built-in username/password provider is intended only for a trusted network or VPN. A public reverse proxy to a loopback dashboard does not automatically activate Hermes authentication: check the bind, require authentication, restrict origin access and verify an unauthenticated management request is denied. A green public /api/status response is not that test.

The dashboard is for operating a Hermes installation, not merely viewing a chat transcript. It brings profile state, sessions, analytics, logs, cron jobs, skills, MCP tools, model/provider settings, and gateway status into one browser surface.

Treat Desktop, Web UI, and the backend as separate failure layers. If Desktop fails after an update but hermes dashboard opens, the core runtime is probably alive and the native client needs repair. If neither opens, start with hermes doctor, the provider smoke test, and current logs.

On WSL, browser reachability depends on where the dashboard process is bound and which environment owns HERMES_HOME. Native Windows and WSL are separate installations; a healthy dashboard with unexpected sessions or settings often means the browser reached the other runtime.

For remote access, distinguish Desktop SSH, Desktop Remote gateway and a browser-only SSH tunnel. In current Settings → Gateways, an SSH entry uses the SSH key, opens a tunnel and starts the remote dashboard; set its optional Hermes path when non-interactive PATH discovery fails. A Remote gateway URL needs an already-running backend. Current registry Test checks HTTP and WebSocket; a manual public /api/status probe does not. Follow the remote connection guide before starting another backend or changing credentials.

Do not describe Bot Mode as a second agent runtime. Each Bot is a Hermes profile under ~/.hermes/profiles/<name>/, with isolated config, memory, skills, credentials, and history. The Desktop Bots tab renders the roster and persistent Bot Chat; CLI parity remains available through hermes -p <bot> chat and profile commands.

Bot routines are profile-scoped Hermes cron jobs, commonly named [bot:<name>] <routine>. Inspect them in the Desktop Routines pane or with hermes cron list; verify run history and the real delivery target instead of expecting every run to appear as a normal conversational reply.

For multiple machines, the Bot belongs to the backend that owns its profile. Desktop Connections can show and route to Bots across local, remote, SSH, cloud, and Docker backends, but the Bot's memory, sessions, tools, and routines stay on the owning machine. A roster mismatch is therefore a connection/backend inventory problem before it is a memory problem.

Select the profile before opening a session or changing settings. Config, API Keys, Skills, MCP, Models and Chat follow the dashboard switcher, and an explicit ?profile=<name> in the URL wins. When a named-profile launch starts the machine dashboard, that profile remains its fallback scope for links without ?profile= during that server lifetime. Do not infer the scope of a bookmarked resume link from its hostname alone. Gateways and session databases remain per-profile.

The workspace selector chooses a folder for the next New chat; resuming a session keeps its existing working directory. The choice is remembered per profile. Rescan if a newly cloned project is absent, or use Other path for an existing directory on the backend. A missing path is rejected rather than silently replaced with the launch directory. Confirm the real working directory before allowing edits; the profile name alone does not identify a repository.

Use Sessions and Logs to reconstruct what happened. Sessions include CLI, gateway, and scheduled runs; Logs expose provider, cron, and delivery failures that a green status card can hide.

Use Analytics to identify token and provider usage before changing models or fallbacks. Cost control is an operational workflow, not only a model-price comparison.

Use the Cron page to inspect schedules and delivery targets, but verify the actual destination. A job is not successful because it appears enabled; it is successful when its expected report or artifact arrives.

The browser Chat tab embeds the real TUI. FastAPI, Uvicorn and the platform PTY helper are core dependencies; standard PM setup includes the web stack. If those dependencies are damaged, the current documentation directs users to hermes pm repair and a restart, rather than blindly mixing package installers into a managed environment.

Localhost is the simplest secure default. For remote private access, use an SSH tunnel or VPN. If you bind to a non-loopback address, Hermes now requires a configured password, Nous OAuth, OIDC, or provisioned deployment session-token provider and fails closed when none is available.

--insecure is retained only as a deprecated compatibility flag. It is a no-op and cannot be used to bypass dashboard authentication.

Use --status to find running dashboard processes and --stop before changing ports or auth. Use --isolated only when a named profile truly needs a dedicated server. It narrows routing, not filesystem access or tenant isolation.

Hermes Desktop remote mode normally connects to a headless hermes serve backend; hermes dashboard can expose the same backend plus Web UI. The public status probe is not enough: authentication, host binding, and the live WebSocket path must all succeed.

The self-hosted dashboard reduces terminal friction but does not own the server, HTTPS, authentication, backups, provider credentials, gateway uptime, or incident recovery.

When a session appears missing, use the Sessions view as orientation, then run hermes sessions stats and FTS5 session search before declaring corruption. The active session may be excluded from a picker and messaging views can be origin-scoped.

Desktop Remote Gateway normally uses hermes serve on port 9119; hermes dashboard can provide the same backend plus Web UI. OpenAI-compatible clients use the separate API server on port 8642, and each profile gateway still needs an end-to-end channel test.

A Cloudflare Tunnel or reverse proxy does not make the dashboard safe by itself. For a public hostname, register Nous OAuth (or configure OIDC), set HERMES_DASHBOARD_PUBLIC_URL=https://dashboard.example.com, run the dashboard on port 9119 with a non-loopback bind so the auth gate engages, and point the tunnel at that local origin. Verify /api/status reports auth_required: true before signing in.

When a channel is connected but silent, leave the dashboard open as context and run hermes -p <name> gateway status --deep --full from a normal terminal. Check for the wrong profile, stale child, or duplicate service, then prove recovery in the exact chat or thread.

A session can look missing when the Sessions page is still on its default Chats filter. Cron, tool, API, ACP, and other automation runs live under Automation or All; Telegram and Discord rows can also be narrowed by exact source. Select the owning profile first, then change the filter before assuming state was lost.

The Status page is also a host-health surface. Current Hermes can warn when available memory or free space crosses elevated or critical thresholds and can flag a suspected out-of-memory restart from the lifecycle ledger. Dismissal is scoped to the current gateway boot, so a restart or escalation reopens the warning.

A blank or timed-out Desktop window does not prove the Hermes runtime is dead. Current community support shows the useful fallback: verify the CLI, launch hermes dashboard --skip-build --no-open when prebuilt assets exist, and point HERMES_WEB_DIST at hermes_cli/web_dist if a reduced PATH hides npm. Preserve profiles and sessions while isolating the client layer.

Remote readiness and remote Chat are different tests. Desktop's readiness probe can succeed through public GET /api/status, while live Chat still fails authentication or the WebSocket guard. After signing in, inspect dashboard and Desktop logs from the same retry window: close code 4401 points to ticket authentication; 4403 points to Host or peer rejection.

Browser Chat runs the actual Hermes TUI behind an authenticated /api/pty WebSocket. A healthy HTTP status page does not prove that this connection works. Inspect the failed request in browser developer tools and the matching server log, but never share cookies, tokens or an unredacted network capture. Native Windows can use dashboard management pages; the PTY-backed Chat tab requires Linux, macOS or WSL2 under the current documentation.

Use Kanban when the question is whether delegated work is actually moving. The board exposes tasks, dependencies, assignees, worker runs, profile lanes, and dispatcher controls; it complements Sessions and Logs rather than replacing execution verification.

Dashboard themes and plugins extend the self-hosted control plane. Themes change the visual system; plugins can add tabs, augment built-in pages, and call authenticated dashboard APIs. This is separate from the native Desktop plugin SDK, so choose the extension surface that matches where operators will work.

A current Desktop connection test checks both HTTP and WebSocket legs. For multi-machine work, name each local, remote, SSH, or cloud connection, test it from Settings → Gateways, and remember that sessions, memory, cron jobs, and messaging state stay on the machine that owns the selected profile.

Use a six-layer recovery ladder when 127.0.0.1:9119 does not open. First run hermes doctor; then hermes dashboard --status; start one process with hermes dashboard --no-open; confirm the exact URL and port printed by that process; repair missing frontend assets with the source checkout's web build or HERMES_WEB_DIST; finally test browser Chat separately from the status page because PTY/WebSocket auth can fail after ordinary HTTP succeeds. Do not rotate provider keys, delete profiles, or reinstall before this ladder identifies the failing layer.

Treat an Agent versus Dashboard version mismatch as a release-skew problem before treating it as lost state. Run hermes --version, inspect the dashboard's displayed version and source checkout, then confirm which executable and HERMES_WEB_DIST the running dashboard process uses. Stop the old dashboard process, update or rebuild one installation, and relaunch it against the same HERMES_HOME. Preserve profiles, sessions, memory, skills, and cron state; deleting them cannot repair a stale frontend bundle or an old long-running backend.

Best use cases

Confirm which profile, provider, memory, skills, and tools an agent is actually using
Inspect recent sessions and logs after a background job or channel failure
Create and monitor cron jobs, then verify delivery in the real destination
Diagnose provider usage, rate limits, fallbacks, and timeouts from one control surface
Review MCP servers and tool exposure before enabling them for a profile or gateway
Open a private browser view into the Hermes TUI
Connect Hermes Desktop to a remote self-hosted backend
Decide whether continued self-hosting or managed FlyHermes better fits the team
Find a missing bot, cron, API, or ACP session by switching from Chats to Automation or All
Catch low-memory, low-disk, or suspected OOM restart conditions before blaming the model
Separate a healthy public status probe from failed remote authentication or WebSocket Chat
Approve guarded commands and answer clarification prompts from the embedded browser TUI
Watch Kanban dependencies and worker runs without confusing board state with completed delivery
Add a private operational tab through the dashboard plugin SDK

How this fits with Hermes Agent

Change a channel without confusing saved and live state

In Channels, Configure writes channel settings; leaving a secret field blank keeps its existing value. Enable or disable changes the active flag but retains the credential on disk. The gateway connects enabled channels on its next restart. Record the owning runtime and current settings before changing one channel, then use Test to inspect configuration, enablement and reported connection. Finally verify one permitted message in the exact destination. A successful save or Test is not proof of delivery.

Choose the right stop or revocation control

Use a channel toggle for a reversible channel configuration change, Pairing → Revoke for an approved messaging user, and the credential issuer for a compromised bot token or API key. Clear pending only removes pending pairing requests; it is not the approved-user revocation action. Do not erase session history as an access-control step. After changing access, verify the rejected user or disabled route cannot start a new permitted task, without exposing credentials in screenshots or logs.

A refused dashboard restart is not a reason to grant broad sudo

The official Channels documentation says a dashboard restart of a system-scope gateway uses sudo -n and fails immediately if the dashboard account lacks the required noninteractive permission. Keep that refusal visible. Ask the service owner to perform the restart through the existing authorized maintenance path, then verify the new gateway state. Do not grant blanket passwordless sudo to make a browser button work. User-scope, system-scope and container supervisors need different operator procedures.

Resolve exit 78 before adding another dashboard

Current Hermes documents one host-owning backend. If a live backend cannot serve the requested host or port, the new launch refuses with exit 78 and names the owner. Run hermes dashboard --status, then inspect the relevant service journal and its launch settings. Reuse the intended backend or deliberately stop its owning service before relaunching. Do not repeatedly change ports, delete profiles or kill an unidentified process. Use --isolated only for a deliberately separate profile server with its own access boundary. Desktop-owned loopback backends are documented as a separate exception.

Separate closing Chat from losing its connection

An interrupted WebSocket can reattach to the same session; hiding the tab pauses automatic reconnect attempts. Closing the browser tab is different: the official guide says the server reaps its PTY and reopening starts a fresh session. Use Sessions to resume the old history deliberately. Saved conversation history is not evidence that an in-flight command survived. Inspect the actual file or external record before repeating a task, and use a separately verified background workflow when work must continue without the browser.

Write a dashboard handoff another operator can use

Record the owning machine and account, launch method, host/port, profile, Hermes home, frontend bundle and authentication path. Test four separate outcomes: the page loads; a signed-out visitor cannot read protected management data on a shared endpoint; signed-in Chat returns a harmless result; and the required gateway replies in its own destination. Save only redacted results and timestamps, never session cookies or environment-file contents. If nobody will own this handoff and recovery work, compare the managed FlyHermes offer instead of exposing an admin port for convenience.

Dashboard opens but Chat disconnects

First note the backend URL, selected profile and session ID. Return to the Chat tab and let it reconnect before sending the task again. Current docs describe a 20-second keepalive for idle sockets, but a proxy with a hard connection-lifetime cap can still close them. Automatic reconnects pause while the tab is hidden or another dashboard page is open. Inspect /api/pty authentication, proxy WebSocket handling and the matching server log if the same failure repeats. A disconnect does not prove that the task failed.

Check the result before retrying

After reconnecting, resume the same session and inspect the expected file or external record. If a message, deployment or other write may already have happened, read back that target before authorizing a retry. Reattachment is documented behavior, not an exactly-once execution guarantee. A missing final chat response is not permission to repeat a side effect.

A harmless browser Chat acceptance check

Choose a test profile and an existing non-sensitive workspace, then start New chat. Ask for the actual working directory and the name of one harmless file, with no edits or network actions. Record the session ID. Switch to another dashboard page, return to Chat and confirm the same history is available. Select a different workspace and resume that old session: its directory should remain unchanged. Start a new chat to test the new folder. These are checks to run on your installation, not a claim that we tested your host or every proxy.

Choose the workspace before starting a phone session

In the self-hosted Chat rail, select the profile and workspace before New chat. The directory choice is remembered per profile and applies to the next new session; Resume retains the existing session directory. On a narrow screen, open the rail as a slide-over. Rescan if a newly cloned repository is absent, then ask for a harmless working-directory check before permitting edits.

Distinguish dashboard health from Bot Screen capacity

A browser admin page, embedded TUI Chat and a Linux Bot Screen are different workloads. If an optional Screen refuses to start, identify its owning host or container and inspect available memory there; do not treat the refusal as proof that ordinary chat is broken. Confirm the required screen capability separately before buying managed hosting or a larger machine.

Keep the dashboard profile separate from the CLI default

The dashboard switcher chooses the profile whose management pages you read or edit. Setting a profile active changes the sticky default for future CLI or gateway runs; it does not replace the dashboard selection. Confirm the profile banner before changing keys or tools. Cron has its own cross-profile filter, and gateways remain independently managed per profile.

Check provider health, not just dashboard status

First select the profile that owns the failing session. In API Keys, distinguish LLM Provider credentials from Tool API Keys: a key marked as set proves only that a value is stored, not that the provider accepts it or has credit. Run doctor from System → Operations for configuration and dependency diagnostics. Then send one short request in Chat and inspect the same session in Logs, including the actual model/provider used. A successful /api/status response reports dashboard and gateway state; it is not a live inference test. If a fallback answered, that does not prove the original provider recovered.

What the dashboard does

It helps operators inspect and manage local Hermes state: active profile, config, sessions, memory, skills, tools, cron jobs, model/provider state, logs, gateway health, and browser Chat when enabled.

What the dashboard does not do

It does not magically host Hermes, secure a VPS, keep Telegram/Discord online, pay provider bills, replace hermes doctor, or prove channel delivery without an end-to-end message test.

When chat works but web search fails

Test the failing capability rather than repeatedly sending a greeting. A model reply does not exercise web search or extraction. Ask for one search on a public topic, inspect the actual tool result, and match its error to the tool provider's credentials in the selected profile. For a model failure, inspect the LLM provider instead. Keep the timestamp, provider/model or tool name, and redacted error; never paste API keys, authorization headers, or cookies into a support request.

Session-loss triage

Confirm the selected profile, inspect Sessions and Logs, run hermes sessions stats, then search one exact phrase. Back up before hermes sessions repair; use --check-only first.

Cloudflare Tunnel with a custom dashboard hostname

Use port 9119 as the tunnel origin, register Nous OAuth for an internet-facing hostname, set the exact HTTPS public URL for callback construction, and confirm the dashboard advertises an active auth provider. Port 8642 is the optional OpenAI-compatible API server, not Web UI.

Gateway incident checkpoint

Use Web UI to confirm the selected profile, provider, sessions, and logs, then move to the gateway runbook for deep process status and an end-to-end channel test. A green card is not transport proof.

Kanban operations

Use the dashboard board to watch dependencies, profile lanes, assignees, worker runs, and dispatcher progress. Verify the final artifact or delivery outside the board before marking the workflow successful.

Custom operator views

Use dashboard themes and plugins for private tabs, page extensions, and authenticated backend routes. Use the separate Desktop plugin SDK only when the extension belongs in the native app.

Recover localhost:9119 without deleting state

Check doctor, process status, the actual listening port, frontend assets, selected profile, and browser Chat/WebSocket in sequence. Preserve HERMES_HOME; a browser connection error does not prove profile or session corruption.

Fix Agent and Dashboard version mismatch

Compare the CLI, running dashboard backend, frontend bundle, executable path, and HERMES_HOME. Stop the stale process, update or rebuild one installation, relaunch, and verify the same profile and session inventory before changing state.

Dashboard or Webapp: choose the right browser surface

The Hermes Dashboard and the gateway Webapp are different browser interfaces. Use hermes dashboard for the administration panel, normally on port 9119. Use hermes webapp for the Desktop-style workspace served by the messaging gateway, normally on port 9120. Both are self-hosted; opening either in a browser does not transfer responsibility for your computer or VPS to a hosting service.

The Webapp path below is documented in the official v0.23.1 source and current Desktop browser-workspace guide, checked November 16, 2026. Older installations and packaged builds can differ. Record the version on the machine running the gateway before following new instructions; a newer laptop client does not update a remote host.

Choose by the job, not by the word Web UI

  • Administer an installation: Dashboard provides configuration, credentials, sessions, logs, skills, MCP and operational controls. Its Chat pane embeds the TUI over PTY/WebSocket; it is not a chat-free monitoring screen. Follow the Dashboard setup walkthrough.
  • Work in the Desktop-style interface from a browser: Webapp provides sessions, profiles, files, Git review, artifacts, previews and a terminal rail through the owning gateway. Native-only features such as global shortcuts, OS-window inspection and the updater remain in Electron. Browser support is not parity with every native feature.
  • Connect the native Desktop application to another host: use the remote-backend decision guide. A Desktop Remote gateway URL, a Dashboard URL and a Webapp URL are not interchangeable just because they reach the same machine.
  • Avoid running the host yourself: compare managed hosting and allowances. FlyHermes is independent of Nous Research. Self-hosted browser access already exists; the commercial distinction is who operates the runtime, updates, authentication and recovery, not who is allowed to chat in a browser.

Open the gateway Webapp without exposing it

These are documented setup steps, not a live-agent test performed by this site. First finish active work and identify the service account and existing gateway owner. The restart below is a real runtime change; do not run it casually against another person's active agent.

# Run on the host that owns the intended Hermes installation.
hermes --version
hermes config set webapp.enabled true
# After active work finishes, using the authorized gateway owner:
hermes gateway restart
hermes webapp --status
hermes webapp

The default address is http://127.0.0.1:9120. Use the URL printed by your installation rather than forcing that port: standalone profile gateways can use another saved port. For a named profile, the documented entry point is hermes -p work webapp, replacing work with an existing profile. See the profile and state-boundary guide.

For local access without a sign-in gate, the launcher creates a private one-use link valid for 60 seconds. Treat an unused link as a credential; do not paste it into a support issue, screenshot or shared chat. A fresh tab or bare address can show sign-in instructions rather than your workspace. Run hermes webapp again instead of copying stale links. The current guide documents hermes webapp --sign-out as signing out Webapp tabs, not every separately authenticated native client.

Secure remote access on the correct listener

The Webapp configuration reference separates webapp.host, webapp.port and webapp.public_url from the standalone Dashboard's address. Setting dashboard.public_url does not publish the Webapp. A same-machine reverse proxy can forward to the loopback Webapp while webapp.public_url names the external HTTPS address; this requires sign-in even when the listener stays on loopback. A proxy in another container cannot reach that container's loopback listener.

Prefer a private tunnel or VPN. For a trusted LAN/VPN, the documented shared-password provider is an option; use OAuth/OIDC for an internet-facing deployment. Do not router-forward port 9120 as a shortcut. A signed-in Webapp user can run commands, access host files and reach the Hermes OS account's environment and credentials. If saved gateway connections are available, anyone who can sign in can also use those connections as their saved identities. Review that inventory before sharing access.

Plain HTTP on a non-loopback address also loses browser secure-context features: microphone, clipboard reading, notifications and the bot screen viewer can be unavailable. Use HTTPS or a tunnel opened as localhost; do not diagnose every missing button as an agent or model failure. The phone access guide covers the client choice separately from hosting.

Verify the workspace, not only a green status

  1. Check hermes webapp --status on the owning host. If the port is taken, authentication is required but unconfigured, or the browser sign-in file is inaccessible, the gateway may still serve native clients while Webapp remains unavailable. Fix the reported cause; don't reset memory or reinstall every surface.
  2. Open a fresh launcher link or use the configured sign-in. Confirm the gateway, selected profile and a non-sensitive working folder before allowing tools to act.
  3. Complete one harmless text exchange, then separately authorize a read-only file check. Inspect the actual result; successful HTTP or a loaded transcript is not proof of a tool turn.
  4. If an older conversation is read-only, current docs distinguish adoptable pre-gateway chats from rows created by a separate WebUI agent and historical automation runs. Review hermes sessions adopt with the owning profile and a backup; do not promise it makes every historical run writable.

An isolated dashboard is not tenant isolation

hermes dashboard --isolated gives a named profile a dedicated server and a narrower visible roster. It does not sandbox sibling profiles. Current Dashboard profile documentation explicitly warns that profiles under one OS user can reach each other's files through filesystem routes or agent tools. Different passwords on those servers do not change the filesystem boundary.

For mutually untrusted people, use separate OS users or containers with appropriate filesystem and network separation. Before buying managed hosting for a team, verify its actual access policy rather than assuming a profile switcher means tenant isolation. Keep the server security checklist and backup procedure in the operating plan.

Sources checked November 16, 2026: official Desktop Use the Desktop workspace from a browser, Open it from your phone or another computer, Reach your other gateways from one Webapp; Configuration Webapp; Dashboard Managing multiple profiles. These establish documented mechanisms and boundaries, not measured uptime, a completed migration or a guarantee that an interrupted task ran exactly once.

Remote dashboard has no sign-in button? Check the authentication mode

A reachable Hermes dashboard is not always a browser-login deployment. Current official docs describe a deployment session-token provider as well as username/password, Nous OAuth and OIDC. A token-only deployment can be working as designed when its login page explains the credential channel instead of offering a sign-in button. Do not disable authentication or add a second password just to make that screen look familiar.

Choose by client and exposure

  • Local browser: start on loopback with hermes dashboard; use the Web UI setup guide to verify the printed address and selected profile.
  • Private remote Desktop: a deployment that already provisions HERMES_DASHBOARD_SESSION_TOKEN can use Desktop's Session token field. The bundled provider registers when that credential is provisioned, unless explicitly disabled. This is a shared deployment credential, not a personal browser account.
  • Browser login on a trusted LAN or VPN: the built-in username/password provider is an option. It is not the recommended public-internet login path.
  • Shared or internet-facing access: prefer Nous OAuth or a conformant OIDC provider. A deployment token has no per-user identity. Keep transport and origin access protected; knowing an admin token grants full dashboard access.

The official token-provider reference documents secret-manager provisioning and file:<path> loading at startup. Do not paste real credentials into a URL, public issue, screenshot, shell history or article example. A secret file must not be placed in the world-readable Nix store. Follow the server security checklist for the deployment's exposure boundary.

Read status without treating it as a successful login

Run this read-only check only against your own backend, over its established private or protected connection. Replace the example URL; the example contains no credential:

DASHBOARD_URL='http://127.0.0.1:9119'
curl --fail --silent --show-error "$DASHBOARD_URL/api/status" \
  | python3 -m json.tool

Inspect auth_required and auth_providers. In the documented token-gated case, the gate is on and the provider list includes session-token; other configured providers may also appear. The status endpoint is public, so a 200 response proves reachability, not authorization. An authorized /api/auth/me request and a real Chat connection are separate acceptance checks. Do not print a token to construct a diagnostic log.

After token rotation, update the saved client credential

The official reference warns that rotating the deployment secret invalidates saved client copies. This can look like HTTP reachable but WebSocket fails in Desktop. Confirm that the client points to the intended backend, have the authorized operator update its Session token field through the secure client interface, then reconnect. Do not rotate unrelated model-provider keys or clear session history to repair a stale dashboard credential.

The provider verifies both REST bearer authentication and the token-mode WebSocket credential. This does not make every connection error a token error: check the backend's loaded provider, the intended host/profile and the same-window redacted logs. Use the remote Desktop diagnostics for authentication versus Host/peer rejection, and the profile guide before assuming a missing conversation was lost. For phone-browser access, the mobile guide explains why a Desktop token field is not a browser sign-in flow.

Decide who will maintain access

Self-hosted Web UI includes real browser Chat. You still own secret provisioning, client updates after rotation, protected networking, backups and recovery. This site promotes FlyHermes independently of Nous Research. Compare self-hosted versus managed responsibilities and current managed plan allowances if operating that lifecycle is the obstacle. Hosting does not establish external account permissions or guarantee recovery of an interrupted task.

Sources checked November 2, 2026: official Dashboard Deployment session-token provider, Authentication (gated mode) and Connecting Hermes Desktop to a remote backend. These are documentation-based decision and acceptance checks; we did not rotate a live token, deploy a token-only server or measure its reliability. No first-supported-release claim is made: check the running backend's documentation/version rather than assuming an older package includes this provider.

Fix a hub setup that cannot find the selected profile's credentials

A dashboard can open successfully while a skill or MCP setup fails to find its required credential. First check which profile the setup targets, not just which account launched the server. The current official profile-management documentation says hub actions—skill install, update and uninstall, MCP install, and toolset setup—use the target profile's .env and configured secret sources, rather than the dashboard process's environment. This also applies when the target is default.

Before installing or rotating a key

  1. Select the intended profile in the sidebar. Check the ?profile= URL value and, when shown, the amber managed-profile banner. Set as active on a profile card changes the sticky default for future CLI/gateway runs; it does not change the dashboard's selected write target.
  2. Inspect that profile's API Keys page for the required key's presence. A key available to the shell that launched the dashboard is not proof that a hub setup can access it. Do not copy the entire default .env into a bot profile to make a setup pass.
  3. From a trusted terminal on the same backend, confirm the target file locations without printing their contents:
hermes -p work config path
hermes -p work config env-path

Replace work with an existing profile. If the credential belongs to an external secret source, verify the target profile's configured source rather than adding a competing copy blindly. For profile boundaries and inherited environment caveats, use the profile guide.

Verify setup, availability and a real request separately

After an authorized credential correction, retry only the intended setup and inspect its result. For MCP, the dashboard Test action connects, lists tools and disconnects; this checks connectivity, not whether every tool can complete a task. Skill toggles take effect on the next session. Start a fresh Chat under the same profile and test one permitted, read-only action against non-sensitive data. A provider request may still incur charges.

If setup succeeds but the action fails, preserve the error category, profile, backend version and timestamp. Follow provider and quota diagnostics for billing/auth errors; do not widen permissions or expose credentials as a generic repair. The dashboard setup guide covers the launch and access checks. Compare managed hosting costs only if operating the host is the obstacle—hosting is not proof of external account permission.

Source checked October 26, 2026: official Dashboard sections Managing multiple profiles, Profiles, Skills and MCP. This is a documentation-based diagnostic checklist, not a reproduced credential failure or a promise that every missing-tool report has this cause.

Restore a dashboard chat that says it is open in another window

A visible transcript, a live browser connection and ownership of a running chat are different things. If New chat works but returning to an earlier conversation says “This chat is open in another Hermes window”, first establish whether another client really owns it. Do not delete the session database, remove lock files or kill every Hermes process to make the warning disappear.

Separate the failure before changing anything

  • The page will not open: follow the localhost and service-owner checks above. No listening dashboard is a different failure from a refused session.
  • Status loads but Chat cannot connect: check authentication and the WebSocket path. A public /api/status response does not prove that /api/pty or /api/ws accepted the client. The remote-backend guide separates those checks.
  • One saved chat is refused while a new chat works: record the selected profile and session ID, then inspect other browser tabs, Desktop windows and terminals on that backend. A genuine live owner should not be displaced by a second writer.
  • Chat reconnects but the result is unclear: inspect the same conversation and the real output before retrying. A missing final answer is not evidence that a file write, message or deployment failed.

The documented orphaned-PTY case

Upstream fix #133847, merged October 6, describes a narrower failure: starting a new dashboard chat rotated the tab's attachment token, but the previous detached terminal process could retain the old session's single-writer lease. Returning to that conversation then produced the “another Hermes window” refusal even though the user had moved away from it.

The fix targets only the detached PTY holding the requested conversation, using the resumed session and its profile's lease holder. It deliberately leaves a terminal with a live viewer and detached terminals for other sessions alone. This is not a reason to bypass normal session ownership.

The published v0.22.2 tag contains that merged fix; this was checked against upstream release ancestry on October 19, 2026. That does not establish the first release containing it or prove that your running backend has updated. Record the version shown by the actual dashboard, not only a newer CLI installed on your laptop. Follow the supported update guide, preserve the owning profile and let active work finish before restarting the intended backend.

There is an important limit: the fix releases the stranded terminal; it does not promise to preserve a turn still running inside that terminal. The upstream change explicitly warns that closing it interrupts in-flight work. Inspect completed outputs before requesting the remaining work again.

A safe restore acceptance check

Use a non-sensitive workspace and an inexpensive model. These are proposed checks for your installation, not a benchmark we ran against your agent.

  1. In Chat A, ask for a short text-only reply with a distinctive harmless marker. Record the profile and session ID; wait for the reply to finish.
  2. Start Chat B and complete another text-only exchange. Return to A through the session list or Sessions → Resume.
  3. Confirm A's marker and history, then send one new text-only message. Passing means the intended conversation accepts it without the unexpected ownership refusal; a green Status page alone is insufficient.
  4. Separately test a temporary network interruption or hiding and returning to the tab. Check that you returned to the same session and did not submit the instruction twice. Do not combine this with a backend restart and call it the same test.

If it still fails, retain the time, backend version, profile, session ID, exact error and redacted logs. Note whether the sequence was A → B → A, a network drop or a process restart. Never include cookies, access tokens or private transcripts in a public issue. The setup walkthrough covers the initial Chat check; the phone guide covers client suspension.

Choose who owns recovery

Disclosure: this site promotes FlyHermes, a managed service independent of Nous Research. Self-hosted Web UI includes real TUI-backed browser Chat. You remain responsible for the host, authentication, updates, backups and incident recovery. FlyHermes is the managed alternative when you want less operational responsibility, not a prerequisite for browser chat and not proof that every interrupted task completes exactly once. Compare self-hosted and managed responsibilities and verify the hosted service's supported workflow before moving consequential work.

Sources checked October 19, 2026: Dashboard Chat and remote-backend reference, TUI connection recovery, targeted lease fix, and v0.22.2 release. A socket reconnect, a resumed transcript and recovery after process death have different guarantees.

Choose the next check by the failed control

If the dashboard is not running yet, follow the Web UI setup sequence before configuring channels. If Save succeeds but Restart fails, use gateway restart troubleshooting: the account that can edit a form is not necessarily authorized to restart a system service.

For a remote host, record the supervisor and account in the VPS operator checklist. A laptop that connects successfully through Desktop remote-backend setup has proved a client connection, not messaging delivery or permission to administer the server.

After a change, use the monitoring control-state checks to distinguish an intentionally disabled webhook from a restart-dependent channel change. Compare self-hosted and managed responsibilities if nobody owns this maintenance, then review managed plan allowances against the actual workflow. Managed hosting does not make external account permissions or usage limits disappear.

Source checked October 16, 2026: the official Channels controls specify saved credentials, enablement, connection testing and gateway restart requirements. These are documented operating procedures, not a claim that this publication run connected a bot or restarted a user's service.

Session cleanup refused: protect live work before pruning

A dashboard that can display sessions is not necessarily allowed to delete them. Current official session-maintenance documentation, checked October 31, 2026, distinguishes a guarded single-session deletion from offline bulk maintenance. Treat a refusal as a safety boundary, not a reason to delete the database or retry in a loop. These are documented procedures and proposed acceptance checks, not a destructive test we ran on a production gateway.

Read the refusal before choosing recovery

  • client_upgrade_required: the delete request has no mutation identity. The official reference names Desktop 0.22.2 and older as affected clients. Update the client that issued the request; a newer backend alone does not upgrade that client.
  • mutation_identity_required: the request carries only part of the required identity. API clients must read the mutation snapshot and send its request ID, expected revision and expected generation. Do not invent values or bypass the revision fence.
  • session_busy: a turn is running or queued. Wait for it to finish and inspect its actual output before trying to remove its history.
  • unknown_execution: a prior turn was lost across a gateway restart. Establish whether its external action happened before attempting recovery. An absent final reply does not establish failure.
  • Exclusive maintenance refused: bulk delete, empty-session deletion, non-dry-run prune and owner backfill need the profile's exclusive gateway lock. The current documentation says a live gateway causes HTTP 409 and no change. Read endpoints and dry-run prune remain available.

These are different HTTP 409 cases. None is evidence that the session database is corrupt. Use the memory and session recovery guide only when diagnostics actually identify a storage problem.

Plan a profile-scoped maintenance window

  1. Identify the owning host and profile in the dashboard. Use the profile isolation guide to avoid stopping another bot's gateway. Record the intended session IDs, retention rule and rollback owner.
  2. Inspect active and queued work, arrange a quiet window and create a protected backup. A session export is an audit artifact, not proof of a restorable full backup. Do not publish transcripts or credentials.
  3. Preview the cleanup where a dry-run is available. Check the candidate list before approving irreversible deletion. A dry-run can be used while the gateway is live; it is not the actual cleanup.
  4. Drain work and stop the intended profile's gateway through its existing authorized service owner. For an explicitly named profile, the command pattern is shown below. If a container or supervisor owns it, use that deployment's established stop procedure; confirm it stays stopped rather than racing automatic restart.
  5. Run only the reviewed maintenance operation in that same profile, then restart through the same service owner. Inspect Sessions and Logs and verify the expected retained history and one permitted channel reply. Follow gateway recovery checks if restart or delivery fails.
# Replace work with the existing profile that owns the target history.
# Read-only orientation first; do not stop unrelated profiles.
hermes -p work gateway status
# Only after work is drained and a maintenance window is approved:
hermes -p work gateway stop
# Perform the reviewed cleanup in that profile's dashboard; no delete-all recipe.
hermes -p work gateway start
hermes -p work gateway status

Do not remove gateway.lock or SQLite sidecars to defeat the refusal. The lock protects a running owner; direct SQL deletion bypasses the documented mutation controls. Single-session deletion also retains small terminal-receipt tombstones indefinitely after executed turns, according to the delete endpoint reference. Deleting visible history therefore is not a promise of complete physical erasure or removal of every execution receipt.

Decide who will own cleanup and recovery

Self-hosted Web UI includes browser Chat; maintenance responsibility is the distinction. Someone must own retention choices, backups, the quiet window, service restart and delivery verification. This site promotes FlyHermes independently of Nous Research. Compare managed hosting and plan allowances when nobody wants to operate that lifecycle, but confirm retention/export policies and supported workflows before moving sensitive sessions. Managed hosting is not a guarantee of unlimited storage, total erasure or exactly-once task execution.

Related Hermes Agent guides

Read the official Dashboard reference →

FAQ

How do I open the Hermes Agent dashboard?

Run hermes dashboard and open its printed URL, normally http://127.0.0.1:9119. Use --port 8080 for a custom Dashboard port or --no-open on a headless server. The separate gateway Webapp normally uses port 9120 and opens with hermes webapp.

Is hermes webapp the same as hermes dashboard?

No. Dashboard is the admin panel on port 9119 with embedded TUI Chat. Webapp is the Desktop-style browser workspace served by the gateway, normally on 9120. It has separate webapp settings and sign-in/lifecycle checks. Both require you to operate the self-hosted runtime.

What does Hermes Web UI manage?

It manages and displays profiles, config, API keys, models, sessions, analytics, logs, cron jobs, skills, MCP, gateway status, and a browser Chat tab. The current Bots roster, canonical Bot Chats, Routines pane, and groups are Desktop Bot Mode surfaces.

Is Hermes Bot Mode part of the Web UI dashboard?

Not as the same surface. A Bot is an ordinary isolated Hermes profile, so its config, memory, skills, sessions, and cron jobs remain visible through the dashboard and CLI. The dedicated Bots roster, canonical Bot Chat, Routines pane, groups, and cross-machine connection experience are built into Hermes Desktop.

Where do Bot Mode routines and run history live?

Routines are profile-scoped Hermes cron jobs and also appear in hermes cron list, commonly with a [bot:<name>] prefix. Inspect their run history and explicit delivery target; do not assume every routine result becomes a permanent Bot Chat message.

Can one dashboard manage multiple Hermes profiles?

Yes. The default machine-level dashboard has a profile switcher. Config, API Keys, Skills, MCP, Models, and Chat follow the selected profile; gateways remain separately managed per profile.

What is hermes dashboard --isolated for?

It starts a dedicated server scoped to a named profile rather than the machine dashboard. It is a routing convenience, not tenant isolation: profiles under the same OS user can reach sibling files through tools or filesystem routes. Use separate OS users or containers for mutually untrusted people.

Does --insecure disable dashboard authentication?

No. It is deprecated and now a no-op. Since the June 2026 hardening, every non-loopback bind requires a configured password or OAuth provider and fails closed without one.

How do I secure a dashboard on a VPS?

Prefer loopback plus an SSH tunnel or private VPN path. For a public HTTPS hostname use Nous OAuth or OIDC, restrict direct origin access, and verify unauthenticated management reads are denied. Built-in username/password auth is for trusted networks or VPNs only.

Can I chat with Hermes in Web UI?

Yes. Every current hermes dashboard launch includes the real TUI Chat over PTY/WebSocket, with no extra Chat flag. FastAPI, Uvicorn and the platform PTY helper are core dependencies. Browser Chat requires Node.js and a POSIX kernel; native Windows users need WSL2 for that pane.

Does a configured API key mean my provider is healthy?

No. API Keys shows whether a credential is stored, not whether a live request will succeed. Select the affected profile, run doctor from System → Operations, and test the failing capability. Check Logs for the provider/model that actually answered, including any fallback. Test web search separately if that is what failed; a normal chat reply does not validate tool credentials.

Can the dashboard prove Telegram, Discord, or cron works?

No. It proves local control-plane state. The final proof is one real reply or delivery in the exact chat, topic, thread, email, or report destination.

How do I see or stop dashboard processes?

Use hermes dashboard --status to list them and hermes dashboard --stop to stop them.

How does dashboard authentication work with Nous Portal?

Run hermes dashboard register to register the self-hosted dashboard and save the OAuth client ID, then use the configured Nous Portal login gate for the deployment.

Why does Hermes Desktop say a remote backend is ready while Chat fails?

A public status response is weaker than the current Desktop registry Test, which checks HTTP and WebSocket. Choose SSH when Desktop should manage its tunnel and remote startup, or Remote gateway for an already-running URL. For SSH discovery failures, verify the optional Hermes executable path before reinstalling. Then select the intended gateway/profile and prove one harmless Chat exchange.

What if npm is unavailable when launching the dashboard?

Build the frontend once from the Hermes source checkout, then use --skip-build or point HERMES_WEB_DIST at the built hermes_cli/web_dist directory.

Is Hermes Web UI the same as FlyHermes?

No. Web UI is the self-hosted operations dashboard. FlyHermes is the managed cloud path for browser/mobile access, connected channels, and uptime without maintaining the runtime yourself.

When should I choose FlyHermes?

Choose it when teammates need reliable browser/mobile access and connected channels but nobody wants to own VPS, authentication, HTTPS, provider keys, gateway restarts, and incident recovery.

Does Hermes Desktop Remote Gateway use the OpenAI-compatible API port?

No. Desktop Remote Gateway normally connects to the headless hermes serve backend on port 9119; hermes dashboard can provide the same backend plus Web UI. OpenAI-compatible clients use port 8642, which is a separate surface.

Can I put Hermes Web UI behind a Cloudflare Tunnel?

Yes, but the tunnel is transport, not authentication. For an internet-facing hostname, use Nous OAuth or OIDC, set HERMES_DASHBOARD_PUBLIC_URL to the exact HTTPS URL, run the dashboard on port 9119 with a non-loopback bind so the auth gate engages, and confirm /api/status reports auth_required: true. Do not expose ports 8642 or 8643 by mistake.

Why is a Hermes bot or cron session missing from the dashboard?

Sessions defaults to Chats, which hides cron, tool, API, ACP, and other automation runs. Select the owning profile, switch to Automation or All, then use the source filter or FTS5 search.

Does the dashboard warn about low memory or disk space?

Yes. The Status page can show elevated or critical memory/disk warnings and a suspected OOM-restart warning from the lifecycle ledger. Treat the banner as host evidence and inspect matching logs before changing the agent configuration.

What do remote dashboard WebSocket codes 4401 and 4403 mean?

4401 means the WebSocket ticket did not authenticate. 4403 means the request guard rejected the connection, commonly because the Host header or remote peer does not match the dashboard bind and URL.

Is a successful /api/status response enough to prove remote Chat works?

No. /api/status is a public readiness probe. Remote Chat separately requires a reachable non-loopback bind, an active authentication provider, a signed-in Desktop session, and a working /api/ws connection.

Does a green dashboard cron row prove delivery?

No. It proves schedule state. Inspect run history and last_delivery_error, then verify the actual message, file, commit, or live URL.

Can I approve commands from Hermes Web Dashboard?

Yes. The dashboard Chat tab embeds the real Hermes TUI, including clarify, sudo, and dangerous-command approval prompts. Keep the dashboard private because those controls can authorize real actions on the owning backend.

Does Hermes Dashboard include Kanban?

Yes. The dashboard can display the Hermes Kanban board, task dependencies, assignees, worker runs, profile lanes, and dispatcher controls. Board state is operational visibility; verify the requested artifact or delivery separately.

Are Web Dashboard plugins the same as Hermes Desktop plugins?

No. Dashboard plugins extend the browser control plane with tabs, slots, and backend routes. Hermes Desktop has a separate native-app plugin SDK. Only use the SDK for the surface you intend to extend.

Why can’t I access the Hermes dashboard on 127.0.0.1:9119?

Usually no dashboard process is listening, it started on another port, the frontend assets are missing, or you are opening localhost on a different machine. Run hermes doctor, hermes dashboard --status, then hermes dashboard --no-open; use the exact URL printed by the running process. For a remote host, tunnel its loopback port instead of opening your laptop's localhost.

How do I fix an Agent versus Dashboard version mismatch?

Compare hermes --version with the version shown by the dashboard, then identify the executable, source checkout, HERMES_WEB_DIST, and HERMES_HOME used by the running process. Stop the stale dashboard, update or rebuild the intended installation, relaunch it, and verify the same profile and sessions. A stale frontend or backend is not repaired by deleting agent state.

What can the Hermes Agent Dashboard not manage for me?

It does not operate your server, install OS updates, secure a public hostname, pay provider bills, restore backups, restart broken gateways, or prove delivery in Telegram, Discord, or a cron destination. Those remain operator responsibilities on a self-hosted deployment.

Should I use Hermes Dashboard, Hermes Desktop, or FlyHermes?

Use Dashboard for browser-based administration of a self-hosted runtime. Use Desktop for a native local or remote workspace with projects, files, terminal, artifacts, and Bot Mode. Use FlyHermes when the desired outcome is managed browser/mobile access and connected-channel uptime without maintaining the host and gateway yourself.

Does the dashboard workspace picker move a resumed session?

No. It sets the directory for the next new Chat on the selected profile. A resumed conversation keeps its existing working directory. Verify the actual directory before authorizing file edits, especially from a phone.

Why does browser Chat disconnect when the dashboard still loads?

The status page uses HTTP, while embedded TUI Chat uses an authenticated /api/pty WebSocket. Check Chat authentication, proxy WebSocket handling and host logs separately. Current docs describe a 20-second idle keepalive, but a hard proxy connection-lifetime limit can still force a reconnect.

Should I resend a task after browser Chat reconnects?

Not until you inspect the same session and its expected output. A disconnect can hide a completed write or a still-running task. Verify the file, message or external record before retrying; reconnecting does not guarantee exactly-once execution.

Why does hermes dashboard exit with code 78?

A live backend already owns the host but cannot satisfy the requested bind or port. Read the error for its owner and inspect dashboard status and service logs. Reuse the intended backend or stop its owning service deliberately before relaunching. A separate profile server needs an intentional --isolated setup; deleting state or looping restarts is not a fix.

Should systemd keep restarting a dashboard that exits 78?

No. The official example uses RestartPreventExitStatus=78 because this is a configuration refusal. Resolve the existing backend owner first. Keep normal crash recovery separate from a deliberate refusal to start.

Will a browser Chat task keep running after I close the tab?

Do not assume so. The official dashboard guide says closing the tab reaps its PTY, while reopening starts a fresh session. Resume saved history explicitly and check actual outputs before retrying. A separately supervised gateway or scheduled worker has a different lifecycle.

What should I check before switching to FlyHermes?

Confirm your exact task, supported channel and models, monthly usage allowance, required account permissions, input access, support and export terms. The advertised managed runtime reduces infrastructure work; it is not a promise of unlimited inference, a universal integration catalog or an SLA on every plan.

Does disabling a channel delete its bot token?

No. The documented channel toggle retains the credential on disk; leaving a secret field blank also preserves the existing value. Revoke a compromised token with its issuer, update the intended runtime and verify recovery. Do not treat a toggle as credential erasure.

Why did Restart gateway fail from Dashboard?

For a system-scope gateway, the dashboard uses sudo -n. If the dashboard account cannot perform that operation noninteractively, the request fails rather than pretending the restart worked. Use the authorized service owner to restart; do not add unrestricted passwordless sudo.

Why does dashboard Resume say this chat is open in another Hermes window?

A live client may legitimately own the session. A separate documented bug stranded a detached dashboard terminal after New chat rotated its attachment token. Upstream fix #133847 targets that orphan and is included in v0.22.2; verify the running backend version. Do not delete state or kill unrelated sessions. Releasing the stranded terminal can interrupt its in-flight turn, so inspect outputs before retrying.

Why can dashboard hub setup miss a key that exists in my shell?

Current Dashboard hub actions use the target profile's .env and configured secret sources, not the dashboard process environment, including when targeting default. Check the sidebar profile, URL and required credential presence without printing secrets. Then verify setup, new-session tool availability and one permitted read-only request separately.

Related Resources