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 5,805 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

Two install paths. One gormes command.

Build from source when you want maximum inspection. Use install.sh when you want a source-backed managed install. Both paths keep the first proof offline.

METHOD 1 · BUILD FROM SOURCE

git clone https://github.com/TrebuchetDynamics/gormes-agent.git
cd gormes-agent
make build
export PATH="$PWD/bin:$PATH"
gormes doctor --offline
gormes --offline

METHOD 2 · INSTALL.SH

curl -fsSLO https://raw.githubusercontent.com/TrebuchetDynamics/gormes-agent/main/install.sh
less install.sh
sh install.sh
gormes doctor --offline

Both paths end at the same gormes command. install.sh also runs gormes setup when a terminal is available. Read the install docs ->

After offline proof

Add a provider

gormes setup provider

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

Smoke-test a turn

gormes --oneshot "hello"

Run a single provider turn 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.
  • Source-backed 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.

856 Go files · 221k lines · 5805 tests

Code base

Static binary, zero CGO, no dynamic library deps.

~40.4 MB

Binary

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

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
  • Source-backed install.sh and setup handoff
  • Onboard/setup flows
  • Provider one-shots
  • 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.

Build from source or inspect install.sh, run the offline doctor, then add credentials only after the machine has proven itself.

Install now Star on GitHub