Desktop v0.18: Projects, Multi-Terminal, and PR Diffs

Hermes Desktop as a First-Class Environment

Hermes has always been a terminal-first application. The CLI and TUI are the primary interfaces, and everything else — the web dashboard, messaging platforms — wraps around the same underlying agent runtime. Hermes Desktop changes that positioning. It is not a wrapper around the CLI; it is a native application (macOS, Linux, Windows) built specifically for developers who do most of their work in a GUI environment and want Hermes to live naturally in that context.

v0.18 is the most significant Desktop update since its initial release. Three new interface systems shipped: First-class Projects, the multi-terminal panel with persistent tabs, and PR-style file diffs in the chat interface. Two visualization features shipped alongside them: a conversation timeline rail for long threads, and the memory graph.

First-Class Projects

The Projects system in Hermes Desktop is the v0.18 answer to the question: what do you do when you are working on multiple active development contexts simultaneously? A project is a named container that holds one or more repositories and a set of "lanes" — independent conversation threads focused on different aspects of the project.

The Desktop sidebar now shows a project tree: your projects at the top level, repositories nested under each project, and lanes nested under each repository. Switching between projects is a single click. Opening a lane loads the full conversation history, the active model, the current goal (if any), and the working directory context for that lane.

Lanes are the critical primitive here. Instead of a single conversation thread per project, you can maintain separate lanes for different concerns — a debugging lane, a feature development lane, a documentation lane — all within the same repository context. Each lane has its own history and its own model selection. Context from the debugging lane does not bleed into the feature development lane.

Multi-Terminal Panel

The single terminal panel in earlier versions of Hermes Desktop was a significant limitation for developers used to multi-pane terminal environments. v0.18 replaces it with a multi-terminal panel: multiple persistent terminal tabs within the Desktop application, each maintaining state independently.

Each tab is a full terminal session connected to the Hermes agent runtime. You can have a tab running a build while another tab has an active Hermes conversation. Tab state persists across Desktop restarts — when you reopen the application, your terminals are where you left them. Tabs can be renamed for organization and reordered by drag.

The multi-terminal panel and the Projects system integrate: when you open a lane, the active terminal tab switches to that lane's working directory automatically. You can override this by manually switching terminals, but the default behavior keeps the terminal and the conversation context aligned.

PR-Style File Diffs in Chat

When Hermes modifies a file during a conversation, v0.18 Desktop now renders the change as a PR-style diff directly in the chat interface — a side-by-side or unified diff view with syntax highlighting, just like a GitHub pull request review. Before v0.18, Desktop showed a text summary of what changed; now you see the actual diff.

This matters for code review workflows. If you ask Hermes to refactor a function and it makes changes you did not anticipate, you can inspect the diff in the chat without switching to a separate diff tool. The diff is part of the conversation record — it persists in the lane history and is visible when you scroll back through the session.

Files with diffs appear with a change indicator in the diff view. Multiple file changes within a single turn are collapsed and expandable, matching the GitHub PR review experience.

Conversation Timeline Rail

Long Hermes sessions — multi-hour debugging flows, day-long autonomous runs — accumulate hundreds of turns. Scrolling to find a specific turn becomes impractical at scale. The conversation timeline rail, a thin column on the right side of the chat interface, provides a condensed visual overview of the entire conversation.

Each section of the timeline is proportional to its density in the conversation. Clicking any point on the rail jumps directly to that section. The rail marks important events with icons: tool calls, goal state changes, subagent delegations, and memory writes are all visible as timeline markers. You can jump to "the point where the agent started writing files" or "the turn where the goal was set" without scrolling linearly through the entire history.

Memory Graph Visualization

The memory graph is a playable radial timeline in the Desktop interface. It visualizes the relationship between memory entries over time: when each entry was created, which session created it, and how entries relate to each other (an entry about a project convention may have prompted the creation of a skill for that project).

The "playable" aspect means you can scrub the timeline and watch the memory graph evolve. You see which memories accumulated quickly (early in your Hermes use) and which have been stable for months. You see where skill creation was triggered by related memory entries. The graph is not just historical information — it is an interface for understanding how your agent's knowledge is organized and how it grew over time.

Connecting Desktop to a Remote Backend

Hermes Desktop is not limited to a local Hermes instance. Via Settings → Gateway → Remote gateway, you can connect Desktop to a Hermes instance running on a remote server — a VPS, a homelab machine, or a team-shared gateway. Enter the remote dashboard URL and credentials, and Desktop operates as a client for that remote instance.

This pattern is useful for developers who run Hermes on a server with more resources but want the Desktop UI experience. The agent runs remotely; the Desktop interface renders locally. All the v0.18 Desktop features — Projects, multi-terminal, diffs, timeline rail, memory graph — work identically with a remote backend.