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.

Choose source build or install.sh, prove the machine offline, then add provider and gateway credentials.

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.

Choose an install path View on GitHub
Source build recommended install.sh available Current scout release: v0.1.05 Static Go binary MIT License Offline doctor before credentials

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 that publishes the stable gormes command. Both paths keep the first proof offline. No runtime Node or npm is needed to open the native UI.

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://gormes.ai/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 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 and inspectable install.sh are the two promoted scout-release paths.
  • Offline doctor runs before provider credentials or token spend.
  • Secrets stay local under the Gormes home, not in the landing workflow.
  • install.sh clones or updates a managed source checkout, builds gormes, verifies the command, and can hand off to setup.
  • Tagged artifacts carry checksums; release signing and package-manager hardening are still in progress.
  • Current measured Linux build: ~39.2 MB (2026-05-06)
  • 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
  • Run onboard/setup flows that surface config, providers, skills, agents, and channel bindings
  • Operate Telegram, Discord, and Slack paths from one binary when configured
  • Inspect and debug local SQLite memory ("Goncho")
  • Browse sessions, config, skills, logs, and audits from local operator surfaces

Gateway support status

Runtime-ready

Telegram, Discord, and Slack.

In roadmap validation

WhatsApp, WeChat, Signal, Matrix, and Mattermost.

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.

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

Pick an install path Star on GitHub