The Agent That GOes With You.

You already love Hermes. Now run it through a surgical Go host that cuts startup tax, isolates platform adapters, and keeps the hot path typed.

Today's trunk ships a Go-native tool registry, Route-B reconnect, a 16 ms replace-latest kernel mailbox, and a split-binary Telegram Scout. Phase 2.C adds thin bbolt session resume without pretending the SQLite memory lattice has already landed.

Run Gormes Read the Roadmap View on GitHub

Phase 2 is live on trunk: 2.A Tool Registry, 2.B.1 Telegram Scout, and 2.C thin bbolt resume are shipped. Python still owns transcript memory until Phase 3.

Quick Start

1. Start your Hermes backend

API_SERVER_ENABLED=true hermes gateway start

2. Build the Go binaries

cd gormes
make build

3. Validate and run the current surfaces

./bin/gormes doctor --offline
./bin/gormes
GORMES_TELEGRAM_TOKEN=... GORMES_TELEGRAM_CHAT_ID=123456789 ./bin/gormes-telegram

Tool-capable kernel. Honest current surface.

$ ./bin/gormes

Gormes
❯ Verify the registry is alive. Give me the current UTC time and a random canary number.

  status   connected to Hermes backend
  tool     now
  tool     rand_int

UTC time captured and canary 731 generated.

What Changes Today

Operational Moat

7.9 MB zero-CGO TUI

The terminal binary stays small, static, and isolated from platform SDK drift while the hot path remains Go-native.

Tool Registry

Go-native tool loop

The kernel accumulates streamed tool calls, executes built-ins in-process, and lets doctor validate the schema surface before tokens are spent.

Route-B

Chaos-resilient turns

Dropped SSE streams are treated as an engineering problem. Reconnect and coalescing keep the latest useful state alive under pressure.

Telegram Scout

Split-binary platform hand

Telegram lives in its own binary with a 1-second edit coalescer, preserving dependency, crash, and binary-size isolation from the TUI.

Phase 2.C

Thin resume, honest scope

bbolt stores only session handles. Python still owns transcript memory and prompt assembly until the Phase 3 lattice and later brain work land.

The Port Is Already Moving

Gormes is not a mockup. Phase 1 established the kernel shell; Phase 2 has already shipped Go-native tools, Telegram, and thin session resume. Phase 3 is still the real memory handoff.

Phase 1 — The Dashboard

Complete. A Go Bubble Tea interface over the existing Hermes backend with the deterministic kernel, Route-B resilience, and the moat story in place.

Phase 2 — The Gateway

In progress. 2.A Tool Registry, 2.B.1 Telegram Scout, and 2.C thin bbolt session mapping are already shipped on trunk.

Phase 3 — Memory

Planned. SQLite + FTS5 transcript memory and the real lattice live here; the current bbolt layer stores only session handles.

Phase 4 — The Brain

Planned. Native agent orchestration and prompt-building move into Go after the memory boundary is real.

Phase 5 — The Final Purge

Remaining Python dependencies are removed and Hermes runs as a fully native Go system.

Help Finish the Port

Phase 2 is active on trunk. The next hard problems are finishing the wiring harness, landing the SQLite memory lattice, and cutting Python out of the brain path.