Your First Session in the Terminal UI

Hermes's primary interface is a sophisticated Terminal User Interface (TUI). It has more in common with Vim or a modern REPL than with a chat window — everything is keyboard-driven, outputs stream live, and long-running tasks can be interrupted and redirected mid-flight.

This lesson walks you through a productive first session.

Launching the TUI

From any directory:

uv run hermes

You'll see something like:

┌─ Hermes · claude-sonnet-4-6 · sandbox:docker ──────────────┐
│                                                            │
│   ~/.hermes/ ready · 0 skills loaded · session #1 opened   │
│                                                            │
│  › _                                                       │
└────────────────────────────────────────────────────────────┘

The bottom line is your prompt. Everything above scrolls; only the prompt pane accepts input.

Multiline Editing

Unlike most chat-style clients, Hermes treats the prompt as a proper editor:

Enter submits.
Shift+Enter inserts a newline — use this for multi-paragraph prompts, code blocks, or bullet lists.
Ctrl+A / Ctrl+E jump to start / end of line.
Ctrl+U clears the current line.
Up / Down navigate prompt history.

Try it — paste a 10-line bug report directly into the prompt; Hermes keeps the formatting intact when it sends the request.

Slash Commands

Slash commands are the control surface. Type / and autocomplete opens a menu. The essentials:

Command	Purpose
`/help`	Command reference
`/clear`	Clear the viewport (session persists)
`/new`	End current session, open a new one (memory is kept)
`/model <name>`	Swap the model mid-session (e.g. `/model gpt-5-mini`)
`/sandbox on	off`
`/skills`	List installed skills
`/memory`	Open the `MEMORY.md` / `USER.md` editor
`/tools`	List available tools + MCP servers
`/quit`	Exit the TUI

All slash commands work in the middle of a session without losing context. Swapping the model with /model keeps the conversation history intact — Hermes re-sends the session to the new model on the next turn.

Your First Task

Let's watch the agent work. Paste this into the prompt:

Look at the current working directory. Summarize what kind of project this is
in two sentences, then tell me one thing I could improve about the structure.

What you'll see stream past:

› Tool call: list_directory(path=".")
  ├── package.json
  ├── src/
  ├── README.md
  └── ... (12 more)

› Tool call: read_file(path="package.json")
  {...streaming output...}

› Thinking: this appears to be a Next.js app using...

› Response:
  This is a Next.js App Router project using Supabase for data and Tailwind
  for styling. The `src/` layout follows the standard Next.js convention.

  Improvement: there's no `tsconfig.json` `paths` alias shown in the top-level
  imports — adding `@/*` → `./src/*` would clean up deep imports.

Tool calls stream in real time, one line at a time. This matters because:

You can interrupt mid-stream. If Hermes starts reading the wrong file, press Ctrl+C and redirect immediately.
You see the reasoning trajectory. When a skill gets promoted to ~/.hermes/skills/, this is the trace that becomes its procedural record.

Interrupt-and-Redirect

This is the single most useful feature of the TUI. Mid-task, you can:

Press Esc to pause the agent after the current tool call finishes.
Type a redirection: "stop reading the frontend, focus on src/lib/actions only".
Press Enter — the agent resumes with the new constraint injected at the top of the context.

Interrupt-and-redirect is a core workflow. It replaces the session-and-restart dance typical of session-bound tools.

Session vs. Memory

A session is one conversation window. It lives in ~/.hermes/sessions.db (FTS5-indexed) and can be searched later. /new ends a session.

Memory spans all sessions. Long-term facts ("I'm a TypeScript developer using Next.js 16", "our codebase uses Prettier with 2-space tabs") live in ~/.hermes/MEMORY.md and USER.md, kept pristine by background summarization.

You'll learn to manage memory explicitly in the next lesson.

Gateway Mode (Optional)

If you want to talk to the same Hermes agent from Telegram, Discord, or Slack instead of the TUI:

uv run hermes gateway --telegram --discord

This starts a background messaging gateway. The agent state, memory, and skills are shared between the TUI and the gateway — you can open the TUI on your laptop, hand off to Telegram on your phone, and pick back up.

This is narrower than OpenClaw's 24+ channel reach by design. Hermes treats messaging as a secondary surface; the terminal is the primary.

What's Next

You've now run the TUI, streamed a real task, and used interrupt-and-redirect. The next lesson explains how Hermes remembers what you care about across sessions — and how to hot-swap between five different memory providers to match your workflow.