OPEN SOURCE · MIT LICENSE · SCOUT RELEASE

Run AI agents from one Go binary.

Gormes runs local agent sessions, provider turns, memory, dashboards, and chat gateways from one Go binary.

No Python runtime. No virtualenv repair. No backend service just to open the UI.

Start offline, prove the machine works, then add provider and gateway credentials.

Scout release: useful today, still early.

Offline TUI, doctor diagnostics, provider one-shots, local SQLite memory, dashboard, and runtime-ready Telegram/Discord/Slack paths are available. Hermes parity, broad channel parity, voice/TTS, plugin/MCP support, and release signing are still hardening.

Run offline in 3 commands View on GitHub
Source build recommended Current scout release: v0.1.02 Static Go binary MIT License Offline doctor before credentials

INSTALL

Build it. Prove it offline.

Start with the inspectable source path. The first proof does not need credentials, a model call, Python, Docker, or Hermes. No runtime Node or npm is required.

1. BUILD FROM SOURCE

git clone https://github.com/TrebuchetDynamics/gormes-agent.git
cd gormes-agent
make build

2. LOCAL DOCTOR

./bin/gormes doctor --offline

3. OFFLINE TUI

./bin/gormes --offline

Provider setup, gateway setup, and convenience installers come after the offline proof. Read the install docs ->

After offline proof

Add a provider

./bin/gormes setup provider

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

Smoke-test a turn

./bin/gormes --oneshot "hello"

Run a single provider turn before starting longer local sessions or gateways.

Check gateway state

./bin/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 want local, inspectable 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

  • Source build is the recommended scout-release path.
  • Offline doctor runs before provider credentials or token spend.
  • Secrets stay local under the Gormes home, not in the landing workflow.
  • Tagged artifacts carry checksums; release signing and package-manager hardening are still in progress.
  • Current measured Linux build: ~38.0 MB (2026-05-04)
  • Progress and benchmark data sync from repo sources during every landing build.

What works today

  • Run a local agent UI with zero runtime dependencies on the offline path
  • Send one-shot prompts to a provider-compatible endpoint
  • Validate your environment before spending tokens
  • Operate Telegram, Discord, and Slack paths from one binary when configured
  • Inspect and debug local SQLite memory ("Goncho")
  • Browse sessions, config, skills, and logs in the local dashboard

Gateway support status

Runtime-ready

Telegram, Discord, and Slack paths are promoted for configured scout-release use.

Tracked, not promoted here

WhatsApp, WeChat, Signal, Matrix, Mattermost, and regional channels stay in docs/roadmap status until live validation is complete.

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 Static Binary

CGO_ENABLED=0 release builds keep the runtime surface in one static Go binary with no Python runtime dependency.

Offline Proof

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

Built-In Doctor

./bin/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.

BUILD STATE

Useful today, still early.

Shipped in scout

  • Offline TUI and doctor
  • Provider one-shots
  • Local SQLite memory and sessions
  • Dashboard inspection
  • Telegram, Discord, and Slack configured paths

Hardening now

  • Provider routing and auth edges
  • 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

64/92 shipped · Full progress tracker →

Explore

Quickstart Install Configuration Architecture GitHub

Start offline. Add credentials later.

The offline path proves the runtime before provider calls, gateway traffic, or token spend.

Build from source Star on GitHub