Agent User Interfaces: Faces Built for Hermes, Not for Generic Chat
Or: when the default WebUI is the wrong product shape, and the real map is surfaces, context, access, and memory.
Source: /Users/nitishchauhan/Downloads/User Interfaces (UI).md
Phase: final
Index: Index - User Interfaces UI
Trajectory: Trajectory - Inner Map
Pipeline: CONSTITUTION - Publishable Asset Pipeline
Master: 00 - Master Index
Status: draft
Slug folder: Work/user-interfaces-ui/
How this one actually started
I was not shopping for another chat box.
Hermes was already the brain. CLI locally. Telegram and WebUI when I am not at the desk. The question that kept showing up in the wild was different: just put Open Web UI in front of it. That answer always felt slightly off. Open Web UI is a strong general chat front-end. An agent stack is not only chat. It wants spending limits, multi-agent profiles, CLI parity, vault context, remote access that does not leak, and memory that grows from observed preferences. A bloated general interface can paper over that mismatch without fixing it.
So the hunt became a landscape, not a single install guide:
Which surfaces are built for agent work, what sits beside chat (apps, mobile, notes), and what capability layer still matters after you pick a face?
What follows freezes that map from a compact research digest: Hermes Client and Hermes WebUI against the Open Web UI default, then Budibase, Conduit, Obsidian, Firecrawl, skill packs, integrations, Tailscale, and the enhancements worth watching (hibernate environments, MEMORY.md / USER.md, subagents).
1. First cut: faces that mirror the agent, not the chat product
Quick pause. Before mobile, before vaults, before cost tricks: what is wrong with “just use Open Web UI”?
Nothing catastrophic. The problem is product shape. General chat UIs accumulate features for multi-model playgrounds, folders, community templates, and everything-but-the-agent. Hermes-adjacent UIs in this map optimize for something narrower: make the browser (or phone) feel like the agent you already run in the terminal.
Hermes Client
Hermes Client is a lightweight, web-based wrapper for the local CLI. Unlike Open Web UI, it is designed specifically to mirror the terminal experience in a browser. Features called out in the landscape:
- Spending limits
- Multi-agent profiles
- CLI-shaped interaction rather than a generic multi-model chat shell
That is the selection criterion in one line: CLI parity in a browser, not a second product personality.
Hermes WebUI (nesquena)
Hermes WebUI (by nesquena) is the popular alternative people reach for when they want out of Open Web UI. Users describe it as cleaner and less bloated, focused on the agent’s needs without the extra surface area of general chat interfaces.
Restated in product terms:
- Lightweight, dark-themed browser interface
- Full parity with the CLI experience
- No complex build step
GitHub home for that line of work: the nesquena/hermes-webui project. The important claim for operators is not “pretty.” It is agent-first chrome with low install friction.
In one line: if your stack is Hermes, the UI should feel like Hermes, not like a multipurpose LLM mall with Hermes bolted on.
2. Beyond the chat pane: tools apps and mobile
Once chat is “good enough,” the next surfaces are not more chat skins. They are places where the agent becomes logic behind work, or a phone-native stream.
Budibase: Hermes as the logic layer
Budibase is recommended for internal business tools. The move is not “chat inside a no-code app.” The move is:
- Forms
- Approval workflows
- Database apps
…where Hermes handles the logic. That is a different UI category: operational apps with an agent brain, not another conversation transcript.
If you only ever evaluate agent systems by how nice the chat is, you miss this entire class of surface.
Conduit: native mobile
Conduit is the native mobile client for Android/iOS in this map, optimized for mobile with:
- WebSocket streaming
- Voice call modes
When Hermes is already the mobile/Telegram-side assistant, Conduit is the rich client path: lower friction than forcing a desktop WebUI through a phone browser for every interaction. PWA vs native is a separate ops choice; the landscape simply names Conduit as the dedicated mobile face.
3. Context that is not the transcript
Chat history is not the same as your notes graph.
Obsidian integration
Obsidian integration connects Hermes to a personal vault and turns notes and backlinks into live context for the agent. That is one of the atypical ideas in this digest, and it is the one that matches how a systems-style operator already works:
- Notes are not dump files for later
- Backlinks are structure
- The agent should read the same graph you think in
If the UI only sees the last twenty messages, it is half-blind next to a vault-backed agent.
Firecrawl: agent-native search, not raw HTML
Firecrawl is a search tool designed for agents. It returns clean, structured data instead of raw HTML, which saves token cost. The operator reading is simple:
- Raw HTML is expensive context
- Structured extraction is hygiene
- Token budget is a UI and architecture concern, not only a billing line
Skill packs and native integrations
Community skill/plugin packs show up for concrete jobs: Debug Doctor, coding workflows, Windows desktop automation, and similar. Hermes also connects natively to surfaces people already live in:
- Google Workspace (Gmail / Docs)
- Slack
- Discord
- Stripe
- Todoist
So the “UI map” is not only browsers and phones. It is every place work already happens, with Hermes as the agent middleware behind those rooms.
4. Access: Tailscale as the boring critical path
Hermes often runs on a local machine or a private VPS. A beautiful WebUI on localhost is useless when you are away from that network.
Tailscale is the frequent answer in this landscape: secure remote access to the agent from a phone or laptop without turning the agent into a public website by accident. For an operator stack, remote access is part of the UI system. If you cannot reach the brain, the face does not matter.
(Other tunnels and reverse proxies exist. This digest pins Tailscale as the common practical layer.)
5. After the face: enhancements that outlast any single UI
UI fashion moves. Three capability layers in the source are the longer bet.
Persistent environments (Daytona / Modal)
Using tools like Daytona or Modal lets the agent’s environment hibernate when idle and wake on demand. That is cost control for VPS users who do not want always-on compute for every idle agent. The UI can stay light while the runtime gets smarter about sleep.
Memory management: MEMORY.md and USER.md
Hermes uses a memory architecture based on files such as MEMORY.md and USER.md. Those files grow as the agent notices preferences (for example, preferred coding libraries). Memory as readable, growing markdown is a different philosophy from opaque “chat memory” toggles:
- Inspectable
- Editable
- Aligned with vault-style operators
Subagents
You can spawn isolated subagents for parallel workstreams and collapse complex tasks into turns that do not keep burning the full parent context. In the language of the digest: parallel workstreams collapsing into zero-context-cost turns. That is not a skin. That is how the agent uses attention.
In one line: pick a clean face, then invest in runtime hibernation, file-based memory, and subagents. Those are the differentiators that survive the next WebUI fork.
6. Operator map (how I would sort the stack)
| Layer | Role in this landscape | Examples from the digest |
|---|---|---|
| Face | Browser / mobile interaction | Hermes Client, Hermes WebUI, Conduit |
| Logic apps | Forms, approvals, DB workflows | Budibase + Hermes as logic |
| Context | Live knowledge for the agent | Obsidian vault + backlinks |
| Search hygiene | Cheap, structured external data | Firecrawl |
| Skills / I/O | Task packs and work apps | Skill packs; Workspace, Slack, Discord, Stripe, Todoist |
| Access | Reach the private agent safely | Tailscale |
| Runtime / memory | Cost and long-horizon quality | Daytona/Modal hibernate; MEMORY.md / USER.md; subagents |
Sort top to bottom when you are stuck: face is necessary, not sufficient. Context, access, and memory decide whether the agent stays useful after the honeymoon install.
Close: what this thread was actually hunting
Not a ranking war about which WebUI wins a beauty contest.
It was a refusal of the default:
- Open Web UI is a general chat product.
- Hermes work wants CLI-shaped faces, agent-need chrome, optional tools apps, vault context, remote access, and a memory/runtime layer that grows with the operator.
If you only change the skin and leave context, access, and memory alone, you still have a chat app. If you wire the full map, the UI becomes what it should have been from the start: a face on an agent system, not the system itself.
Draft for Labs review. Authority landscape from research digest; openings and glue follow Trajectory - Inner Map.