GO-NATIVE · OFFLINE-FIRST · MIT LICENSE

Run AI agents from a single binary.

One static binary. No Python runtime. No Docker daemon. No dependency drift.

Scout release.

Offline TUI, onboarding, provider turns, local SQLite memory, dashboard, and Telegram/Discord/Slack gateway paths are available now. Release signing, voice/TTS, and full Hermes parity are still hardening.

Install See features
30 Hermes skills 1 Go binary 6,044 tests MIT License

WHY GORMES

Python-stack agents fail for boring reasons.

The model is not usually the fragile part. Operations are:

  • dev, staging, and prod stop matching
  • virtualenvs and package wheels drift across hosts
  • long turns die on dropped streams
  • tool wiring fails after tokens are already burning

Gormes cuts out that failure class

Single Binary Runtime

Static Go builds keep the runtime surface in one binary with no Python runtime dependency.

Offline Proof

gormes --offline starts the native TUI without credentials, network calls, Python, Node, Docker, or Hermes.

Built-In Doctor

gormes doctor --offline checks local readiness before provider calls or token spend.

Provider Turns

One-shots and the TUI use configured provider-compatible endpoints from the same binary.

Local SQLite Memory

Sessions, durable context, diagnostics, and queue state stay in local SQLite.

Visible Limits

Full Hermes parity, broad channel parity, voice/TTS, MCP/plugin parity, and release hardening remain in progress.

What works today

Runtime

  • Offline TUI with zero dependencies
  • One-shot provider turns
  • Built-in environment doctor

Memory & State

  • Local SQLite sessions ("Goncho")
  • Durable context across restarts
  • Session browser and debug tools

Gateways

  • Telegram bot integration
  • Discord bot integration
  • Slack app integration

Operations

  • Local dashboard at 127.0.0.1:43827
  • Security and secrets audit
  • Gateway logs and status

Gateway support status

Runtime-ready

Telegram, Discord, and Slack.

In roadmap validation

WhatsApp, WeChat, Signal, Matrix, and Mattermost.

INSTALL

Install first. Build from source when needed.

Use install.sh for the release-first managed install. Build from source when you need local inspection, custom flags, or unsupported platform fallback. Both paths keep the first proof offline.

METHOD 1 · INSTALL.SH

curl -fsSL https://github.com/TrebuchetDynamics/gormes-agent/releases/latest/download/install.sh | sh
gormes --version
gormes doctor --offline

METHOD 2 · BUILD FROM SOURCE

git clone https://github.com/TrebuchetDynamics/gormes-agent.git
cd gormes-agent
mkdir -p bin
CGO_ENABLED=0 go build -trimpath -o bin/gormes ./cmd/gormes
./bin/gormes doctor --offline
./bin/gormes --offline

Use install.sh for the published gormes command on PATH, or ./bin/gormes from a source checkout when you are developing Gormes itself. Read the install docs ->

After setup

Add a provider

gormes setup provider

Configure endpoint credentials only after the local doctor and offline TUI prove the machine.

Start chat

gormes chat

Open a provider-backed terminal chat before starting longer local sessions or gateways.

Check gateway state

gormes gateway status

Promote Telegram, Discord, or Slack only after the configured channel reports clean status.

Who this is for

For

Developers and operators who need reliable, local agent infrastructure that survives restarts, bad networks, and dependency drift.

Not for yet

Teams that require signed enterprise releases, full Hermes parity, voice/TTS, or broad channel parity today.

Trust posture

  • Offline doctor runs before any token spend.
  • Secrets stay local under ~/.gormes.
  • Release-first install.sh you can inspect before running.
  • Every commit passes go test, progress validate, and git diff --check.
  • Tagged releases with SHA-256 checksums.

HOW IT'S BUILT

Systematic porting with full test coverage.

Every generated change passes tests, parity checks, and repo validation before landing. Hermes is the parity oracle; engineering rigor is the differentiator.

Loop output, measured today

770+

Validated rows shipped

Each carries a contract, fixtures, and acceptance evidence.

880 Go files · 230k lines · 6044 tests

Code base

Static binary, zero CGO, no dynamic library deps.

~45.4 MB

Binary

Linux/amd64, linux/arm64, darwin/amd64, darwin/arm64 today.

~28.7 MB

Runtime RSS

Offline doctor peak RSS: ~28.7 MB (2026-05-15)

Validation-gated commits

Every commit must pass go test, progress validate, and git diff --check before landing. No silent failures, no skipped hooks.

Hermes is the parity oracle

Upstream Hermes is the Python reference. The loop sweeps for gaps and turns them into test-driven slices.

Read how the loop works ->

CURRENT STATE

Core runtime shipped. Production hardening and broader parity are in progress.

Shipped in scout

  • Offline TUI and doctor
  • Release-first install.sh and setup handoff
  • Onboard/setup flows
  • Provider-backed chat
  • Local SQLite memory and sessions
  • Dashboard inspection
  • Logs, security audit, and secrets audit
  • Telegram, Discord, and Slack configured paths

Hardening now

  • Provider routing and auth edges
  • Learning loop and operator feedback paths
  • Tool safety and sandboxing
  • Browser/web tools
  • Release checksums, signing, and package-manager lanes

Later

  • Voice/TTS parity
  • Broad channel parity
  • Plugin/MCP parity
  • Enterprise release polish

Next milestone

Production-stable Go-native runtime with signed releases and broader Hermes parity

View full roadmap ->

Explore

Quickstart Install Configuration Architecture Built with GitHub

Prove the runtime locally before you ever spend a token.

Run the release-first installer or build from source, run the offline doctor, then add credentials only after the machine has proven itself.

Install now Star on GitHub