Skip to content
/
Tier A A6 Multi-agent orchestrator

Gas Town

gas-town · gastownhall/gastown · ★ 16k · last commit 2026-05-26

Coordinate 20-30 concurrent AI coding agents on shared repos with persistent work state, crash recovery, and autonomous health monitoring.

Best whenAgents should run immediately when work appears (no confirmation) — the hook having work IS the assignment; this is physics, not politeness.
Skip ifAsking for confirmation before starting hooked work, Direct terminal output for inter-agent communication (use gt nudge)
vs seeds
claude-flow(multi-agent + git-worktrees + persistent state) but differs architecturally: Go binary instead of Node.js, Dolt/DoltHub…
Primitive shape 13 total
Commands 3 Skills 4 Subagents 6
00

Summary

Gas Town — Summary

Gas Town (gastownhall/gastown) is a multi-agent workspace manager written in Go, authored by Steve Yegge, that coordinates 20-30 concurrent AI coding agents (Claude Code, Codex, GitHub Copilot) working on shared Git repositories. Its core abstraction is the Rig (a git-backed project container), within which Polecats (worker agents with persistent identity) receive work units called Beads and execute them in ephemeral sessions whose state survives across restarts via git worktree-backed Hooks. The Mayor/Deacon/Witness three-tier watchdog architecture autonomously monitors agent health, routes escalations, and triggers recovery — so human oversight is needed only for P0 escalations. Work is tracked through Beads (Steve Yegge's own git-native JSONL issue tracker at github.com/steveyegge/beads), and complex multi-step workflows are expressed as Molecules (TOML formula templates instantiated as Wisps). Gas Town also ships a Federated Wasteland network linking multiple Gas Towns via DoltHub for cross-organization work sharing.

Compared to seeds: closest to claude-flow (multi-agent orchestration, git worktrees, persistent agent state, merge queue), but Gas Town uses a Go CLI binary (gt) + Dolt database + DoltHub federation rather than Node.js + SQLite; its watchdog hierarchy (Mayor/Deacon/Witness/Dogs) is more operationally elaborate, and Beads integration gives it its own issue-tracking substrate rather than a generic task file.

01

Overview

Gas Town — Origin and Philosophy

Origin

Gas Town is created by Steve Yegge (author of famous engineering blog posts, ex-Google/Amazon), the same person who built the Beads git-native issue tracking system. Gas Town is the multi-agent orchestration layer that wraps around Beads, providing spatial metaphors, persistent agent identity, and a production-grade supervision tree.

The organization name is gastownhall, and the npm package author field is "author": "Steve Yegge". Repository created December 2025, 15,581 stars as of May 2026.

Core Philosophy: The Propulsion Principle (GUPP)

The .beads/PRIME.md file states the operating contract verbatim:

If you find work on your hook, YOU RUN IT.

No confirmation. No waiting. No announcements. The hook having work IS the assignment. This is physics, not politeness. Gas Town is a steam engine — you are a piston.

Failure mode we're preventing:

  • Agent starts with work on hook
  • Agent announces itself and waits for human to say "ok go"
  • Human is AFK / trusting the engine to run
  • Work sits idle. The whole system stalls.

Key Philosophical Positions

  1. Autonomous execution over confirmation — agents run immediately when work is present; no mid-task pause, no approval requests.
  2. Work not done until pushed — session close protocol requires git push before claiming completion.
  3. Identity persistence, session ephemerality — Polecats have stable names and work histories but ephemeral runtime sessions; crashing is expected and safe.
  4. Seance for continuity — dead sessions are queryable by successor agents via gt seance, enabling knowledge handoff without re-explanation.
  5. Beads as the substrate — issues ("beads") live in .beads/issues.jsonl inside the git repo, making them diff-able, branch-aware, and AI-friendly without web UIs.

The Spatial Metaphor

Gas Town uses a Western/industrial spatial vocabulary:

  • Town = workspace directory
  • Rigs = project containers (git repos)
  • Crew Members = human workspaces
  • Polecats = worker agents
  • Mayor = primary AI coordinator
  • Deacon = background supervisor
  • Witness = per-rig lifecycle manager
  • Refinery = merge queue processor
  • Wasteland = federated cross-town work network

Beads Integration Philosophy

From AGENTS.md:

This project uses beads for issue tracking. Issues live in .beads/ and are tracked in git. Two CLIs: bd (issue CRUD) and bv (graph-aware triage, read-only). NEVER run bare bv — it launches interactive TUI. Always use --robot-* flags.

02

Architecture

Gas Town — Architecture

Distribution

  • Primary: brew install gastown (macOS/Linux) — recommended; produces signed binary
  • npm: npm install -g @gastown/gt — thin JS wrapper that installs Go binary
  • Go source: go install github.com/steveyegge/gastown/cmd/gt@latest (Linux only; unsigned on macOS = SIGKILL)
  • Docker Compose: full environment including dashboard

Required Runtime

  • Go 1.25+
  • Git 2.25+
  • Dolt 1.84.0+ (DoltHub's MySQL-compatible version-controlled DB)
  • beads CLI (bd) 0.55.4+ (Steve Yegge's separate repo: github.com/steveyegge/beads)
  • bv (Beads Viewer) — read-only graph analysis TUI
  • sqlite3 (convoy DB queries)
  • tmux 3.0+ (recommended for multi-agent sessions)
  • Claude Code CLI (default agent runtime)
  • Codex CLI (optional)
  • GitHub Copilot CLI (optional)

CLI Binary

Binary name: gt

Key subcommands (partial list from README):

  • gt install <dir> --git — create workspace
  • gt rig add <name> <url> — add project container
  • gt crew add <name> --rig <rig> — create crew workspace
  • gt mayor attach — start Mayor session
  • gt prime — inject full context into current agent session
  • gt nudge <target> "<msg>" — send message to another agent's session
  • gt mail inbox/read/send — mailbox operations
  • gt mol status/wisp/attach — molecule (workflow) management
  • gt patrol new --role <role> — start watchdog patrol cycle
  • gt escalate -s <SEVERITY> "<description>" — severity-routed escalation
  • gt seance [--talk <id> -p "<q>"] — session discovery / predecessor query
  • gt convoy/gt sling — work dispatch with Bead IDs
  • gt done — polecat work completion + sandbox cleanup
  • gt hook — check what work is on current agent's hook
  • gt peek <path> — check agent status
  • gt config agent list — list available runtimes

Directory Tree (workspace)

~/gt/                          # Town workspace
├── settings/
│   └── escalation.json        # Escalation routing config
├── <rig-name>/                # Per-project container
│   ├── .beads/                # Git-native issue store
│   │   ├── issues.jsonl       # All beads/issues
│   │   ├── PRIME.md           # Agent startup context
│   │   └── config.yaml        # Beads config
│   ├── crew/
│   │   └── <username>/        # Human workspace
│   └── polecats/
│       └── <agent-name>/      # Worker agent sandbox (git worktree)

Repository Structure

gastownhall/gastown/
├── cmd/
│   ├── gt/                    # Main CLI binary
│   ├── gt-proxy-client/
│   └── gt-proxy-server/
├── internal/                  # Go internal packages
├── plugins/                   # Background daemon plugins
│   ├── compactor-dog
│   ├── dolt-backup
│   ├── stuck-agent-dog
│   └── (10 more)
├── .claude/
│   ├── commands/              # Claude Code commands (patrol, backup, reaper)
│   └── skills/                # Claude Code skills (crew-commit, ghi-list, pr-list, pr-sheriff)
├── .beads/                    # Beads tracking for Gastown itself
├── docs/                      # Extensive docs (concepts, design, guides)
├── npm-package/               # npm wrapper
├── templates/                 # Agent prompt templates
└── docker-compose.yml

Target AI Tools

Claude Code (primary), Codex CLI (optional), GitHub Copilot CLI (optional). The gt config agent list command shows available configured runtimes.

Language

Go (primary CLI), JavaScript (npm wrapper), Shell (scripts/plugins).

03

Components

Gas Town — Components

Claude Code Commands (.claude/commands/)

Name Purpose
patrol.md Run one patrol cycle for the current agent role (witness, deacon, or refinery). Dispatches gt patrol new --role <role>.
backup.md Trigger backup operations via Dolt
reaper.md Reap dead/zombie agent processes

Claude Code Skills (.claude/skills/)

Name Purpose
crew-commit Stage, commit, and push code changes from crew workspace
ghi-list List GitHub issues for the current rig
pr-list List open pull requests for the current rig
pr-sheriff Review and gate pull requests through the Refinery

Background Daemon Plugins (plugins/)

Name Purpose
compactor-dog Auto-compact agent context logs
dolt-archive Archive Dolt database snapshots
dolt-backup Backup Dolt data
dolt-log-rotate Rotate Dolt operation logs
dolt-snapshots Snapshot management
git-hygiene Prune stale branches, dead worktrees
github-sheriff GitHub repository policy enforcement
gitignore-reconcile Keep .gitignore files consistent across rigs
quality-review Run automated code quality checks
rebuild-gt Self-update Gas Town binary
stuck-agent-dog Detect and recover stuck agents (>threshold)
submodule-commit Handle git submodule commit propagation
tool-updater Update dependent tools (bd, bv)

CLI Commands (binary gt) — Key Categories

Workspace: install, up, config Rig management: rig add, rig list, rig status Agent control: crew add, mayor attach, prime, nudge, peek, seance Work dispatch: sling, convoy, hook, done, escalate Molecule/workflow: mol status, mol wisp, mol attach, mol detach, patrol new, patrol report Communication: mail inbox, mail read, mail send, nudge

Beads CLI (separate binary bd)

Command Purpose
bd ready Unblocked issues ready to work
bd create Create a new bead/issue
bd show <id> Full details + dependencies
bd update <id> Update status, notes, labels
bd close <id> Mark complete
bd dep add <a> <b> Set dependency (a depends on b)
bd sync Sync beads with git
bd formula list Available workflow formulas
bd cook <formula> Instantiate a formula
bd mol list Available molecules
bd mol wisp <proto> Create work wisp

Beads Viewer CLI (bv — read-only)

Flag Purpose
--robot-triage Ranked picks, quick wins, blockers, health
--robot-next Single top pick + claim command
--robot-plan Parallel execution tracks
--robot-alerts Stale issues, cascades, mismatches
--robot-insights Full graph metrics: PageRank, betweenness, cycles

Watchdog Agents (runtime roles)

Role Purpose
Mayor Primary AI coordinator; full workspace context; human entry point
Deacon Background supervisor; continuous patrol cycles across all rigs
Witness Per-rig lifecycle manager; monitors polecats; detects zombies
Refinery Per-rig merge queue processor; Bors-style bisecting merge
Polecats Worker agents; persistent identity; ephemeral sessions; run work from hooks
Dogs Infrastructure workers dispatched by Deacon (e.g., Boot for triage)
05

Prompts

Gas Town — Prompts

Prompt 1: The Propulsion Principle (.beads/PRIME.md)

Technique: Imperative behavioral contract with anti-pattern enumeration. Uses physics metaphor to override conversational AI's default ask-before-acting tendency.

## The Propulsion Principle (GUPP)

**If you find work on your hook, YOU RUN IT.**

No confirmation. No waiting. No announcements. The hook having work IS the assignment.
This is physics, not politeness. Gas Town is a steam engine — you are a piston.

**Failure mode we're preventing:**
- Agent starts with work on hook
- Agent announces itself and waits for human to say "ok go"
- Human is AFK / trusting the engine to run
- Work sits idle. The whole system stalls.

## Startup Protocol

1. Check your hook: `gt mol status`
2. If work is hooked → EXECUTE (no announcement, no waiting)
3. If hook empty → Check mail: `gt mail inbox`
4. Still nothing? Wait for user instructions

Prompt 2: Patrol Command (.claude/commands/patrol.md)

Technique: Role detection → conditional dispatch → step-by-step task enumeration with explicit bash commands. The command restricts available tools via allowed-tools: frontmatter.

---
description: Run a patrol cycle for the current agent role (witness, deacon, or refinery)
allowed-tools: Bash(gt patrol:*), Bash(gt hook:*), Bash(gt mail:*), Bash(gt nudge:*), Bash(gt peek:*), Bash(gt escalate:*), Bash(gt dolt status:*), Bash(bd :*), Bash(gt mol:*)
argument-hint: [witness|deacon|refinery]
---

# Patrol

Run one patrol cycle for the specified role. Patrol is a continuous monitoring
loop — each invocation executes one cycle of the patrol formula.

## Witness Patrol Steps

### 1. inbox-check
```bash
gt mail inbox

Process any pending messages: POLECAT_DONE, MERGED, HELP, escalations.

4. survey-workers

Check all active polecats in the rig:

gt peek gastown/polecats

For each active polecat:

  • Check if session is alive (has recent activity)
  • Detect zombies: session dead but agent_state says working Nudge idle polecats:
gt nudge gastown/polecats/<name> "Progress check — what's your status?"


## Prompt 3: Communication Protocol (`AGENTS.md`)

**Technique**: Prohibition + exclusive channel specification. Prevents parallel-agent coordination via natural language output.

```markdown
## Gas Town Multi-Agent Communication

**Important:** `gt nudge` is the ONLY way to send text to another agent's session.
Never print "Hey @name" — the other agent cannot see your terminal output.

`gt nudge` sends a message directly to another agent's active session:

```bash
gt nudge mayor "Status update: PR review complete"
gt nudge laneassist/crew/dom "Check your mail — PR ready for review"
09

Uniqueness

Gas Town — Uniqueness and Positioning

Differs from Seeds

Closest to claude-flow in the multi-agent / git-worktree / persistent-state archetype, but Gas Town differs in several concrete dimensions:

  1. Go binary vs Node.js: gt is a native Go binary with Homebrew distribution; claude-flow is npm/Node.js. Gas Town's binary is not a thin wrapper over Claude CLI — it is its own runtime.

  2. Dolt instead of SQLite: claude-flow uses SQLite for memory. Gas Town uses Dolt (a MySQL-compatible version-controlled database by DoltHub) which adds commit history, branch support, and remote push to DoltHub for federation.

  3. Beads as issue substrate: Gas Town delegates task tracking to Steve Yegge's separate beads ecosystem (bd + bv CLI, JSONL in git). This means work items are diff-able, branch-aware, and viewable offline. claude-flow uses its own task JSON format.

  4. Production watchdog hierarchy: The Mayor/Deacon/Witness/Refinery/Dogs five-tier supervision architecture has no equivalent in any other seed. claude-flow has spawning but not autonomous health monitoring with escalation routing to email/SMS.

  5. Bors-style merge queue (Refinery): Merge gating via a dedicated AI agent running a bisecting queue is unique. Other frameworks have commit automation but not merge queue arbitration.

  6. Federated Wasteland network: Cross-Gas-Town work federation via DoltHub has no equivalent in the seeds.

Compared to agent-os (closest markdown-scaffold seed): Gas Town is architecturally opposite — agent-os is zero-primitive markdown scaffolding; Gas Town is a rich binary ecosystem with its own database, issue tracker, and federated network.

Positioning

Gas Town targets teams running 20-30 concurrent AI agents on shared repositories where: agents crash frequently, human oversight should be minimal, work must survive agent restarts, and merge conflicts need automated mediation. It is the most operationally complete multi-agent system in the corpus — closer to a CI/CD platform than a prompt framework.

Observable Failure Modes

  1. Beads dependency: Requires bd 0.55.4+ — a separate binary from Steve Yegge's repo. If beads has breaking changes, Gas Town workflows break.

  2. Dolt complexity: Dolt installation and maintenance is non-trivial. The README warns that go install on macOS produces unsigned binaries that SIGKILL.

  3. tmux dependency: Full multi-agent experience requires tmux. Running without tmux degrades the Mayor session management.

  4. Propulsion Principle risk: The "run immediately, no confirmation" model can result in agents burning API credits on incorrect work if hook content is malformed or misrouted.

  5. DoltHub federation: Wasteland features require DoltHub access — adds external service dependency.

Cross-References

  • Beads (bd/bv) is a separate project by Steve Yegge: github.com/steveyegge/beads — Gas Town is built on top of Beads, not a fork.
  • beads-ui (mantoni/beads-ui) provides a local web UI for the bd CLI — a companion viewer for Gas Town's work tracking layer.
  • SuperBeads (EliaAlberti/superbeads-universal-framework) also integrates with Beads but as a lighter Claude Code methodology layer.
04

Workflow

Gas Town — Workflow

Phases

Phase Trigger Artifact
1. Workspace setup Human runs gt install ~/gt --git ~/gt/ Town directory + Dolt DB
2. Rig creation gt rig add <name> <url> Rig container with .beads/
3. Mayor session gt mayor attach Active Claude Code session with workspace context
4. Work creation bd create "..." or gt convoy Bead JSONL entry in .beads/issues.jsonl
5. Work dispatch gt sling <bead-id> <polecat> or conveyor dispatch Hooked work item assigned to polecat
6. Polecat startup Agent session starts gt mol status check → gt prime context injection
7. Execution Polecat works through molecule checklist Code changes in git worktree
8. Verification Per-molecule step: build/test gate Test pass / verification artifact
9. Completion gt done MR queued to Refinery; sandbox nuked
10. Refinery merge Refinery patrol cycle Verified code merged to main; Bead closed
11. Watchdog monitoring Continuous Witness/Deacon patrol Health reports; escalation beads

Approval Gates

Gate Type Mechanism
Refinery verification Automated gt done triggers MR; Refinery runs verification gates before merge
P0 escalation to human Alert-based gt escalate -s CRITICAL → Deacon → Mayor → email/SMS to human
Seance handoff question Async query Successor agent asks predecessor via gt seance --talk <id> -p "..."

Molecule Lifecycle

Formula (TOML) → bd cook → Protomolecule (frozen)
                                    │
                    ┌───────────────┴──────────────┐
                    │                              │
             root-only wisp                    bd mol pour
             (ephemeral, steps inline)         (persistent sub-wisps)

Root-only wisps: Steps NOT materialized as DB rows; read inline from formula. Default for high-frequency work (~400 wisps/day vs ~6,000).

Poured wisps: Steps materialized with checkpoint recovery. Used for expensive, low-frequency workflows (releases).

Session Protocol

From .beads/PRIME.md (verbatim):

  1. Check hook: gt mol status
  2. If work hooked → EXECUTE (no announcement, no waiting)
  3. If hook empty → Check mail: gt mail inbox
  4. Still nothing? Wait for user instructions

Session close (mandatory before "done"):

  1. git status
  2. git add <files>
  3. git commit -m "..."
  4. git push
  5. bd sync (commits beads changes)

Escalation Flow

Agent → gt escalate -s <SEVERITY> "description"
         └→ Deacon receives
              ├→ resolves → updates bead, re-slings work
              └→ forwards → Mayor
                   ├→ resolves
                   └→ forwards → Overseer → resolves

Severity routing:

  • MEDIUM (P2): bead + mail mayor
  • HIGH (P1): bead + mail + email
  • CRITICAL (P0): bead + mail + email + SMS
06

Memory Context

Gas Town — Memory and Context

State Storage

Beads (primary work state)

  • File: .beads/issues.jsonl (per-rig, git-tracked)
  • Format: JSONL — one JSON object per bead/issue
  • Persistence: global (git-committed, pushed to remote)
  • Sync: bd sync → Dolt commit → git push

Dolt Database (convoy/molecule state)

  • Type: MySQL-compatible version-controlled DB (DoltHub)
  • Content: convoy metadata, molecule instances, molecule steps, agent state
  • Persistence: global (DoltHub remote for federation)
  • Query: sqlite3 for convoy DB, dolt CLI for full DB ops

Git Worktrees (per-polecat isolation)

  • Each polecat gets an isolated git worktree in <rig>/polecats/<name>/
  • Work state survives crashes because files are in the worktree, not agent memory
  • Hooks path: <rig>/hooks/<polecat-name>/ — stores pending work items

Seance Logs (session history)

  • File: .events.jsonl per agent session
  • Content: agent actions, decisions, tool calls from previous sessions
  • Query: gt seance discovers sessions; gt seance --talk <id> -p "<question>" sends one-shot query to predecessor

Context Injection

gt prime is the canonical context-loading command. On session start (or after compaction/clear), agents run gt prime to receive:

  • Their role context (Mayor/Deacon/Witness/Refinery/Polecat)
  • Active rig and project state
  • Hooked work items (via molecule checklist, inlined from formula)
  • Pending mailbox items

The PRIME.md file in .beads/ and AGENTS.md in the repo root are secondary context injected for all agents.

Context Compaction Handling

The compactor-dog plugin (background daemon) handles auto-compaction. Agents explicitly call gt prime after Claude Code's /compact to restore context. Recovery protocol: gt prime at session start, clear, or after compaction.

Cross-Session Handoff

Polecats have persistent identity (name, work history, role) stored in Dolt DB, even though their Claude Code sessions are ephemeral. When a new session starts:

  1. gt mol status — check hooked work
  2. gt prime — inject role context + molecule checklist
  3. gt seance — query predecessor sessions for decisions/context

Federated State (Wasteland)

Across Gas Towns connected via DoltHub:

  • Rigs post wanted work items
  • Claim work from other towns
  • Submit completion evidence
  • Earn portable reputation via multi-dimensional stamps
07

Orchestration

Gas Town — Orchestration

Multi-Agent Architecture

Gas Town is explicitly designed for 20-30 concurrent agents. The hierarchy:

Human (optional, AFK-safe)
    │
    └── Mayor (Claude Code session, full workspace context)
              │
              └── Deacon (background supervisor, continuous patrol)
                       │
                       ├── Witness (per-rig polecat monitor)
                       │
                       ├── Refinery (per-rig merge queue)
                       │
                       ├── Dogs (dispatched maintenance workers)
                       │
                       └── Polecats[] (worker agents, 1..N per rig)

Orchestration Pattern

Hierarchical with autonomous execution at every tier. The Mayor can delegate to Polecats directly or via Deacon dispatch. Polecats execute independently; Witness monitors them; Refinery gates their output.

Isolation Mechanism

Git worktrees — each Polecat gets an isolated worktree in <rig>/polecats/<name>/. Code changes are isolated per agent until the Refinery merges to main. No container or MicroVM isolation; filesystem isolation via git worktrees only.

Communication Protocol

Agents communicate exclusively via gt nudge (immediate delivery to active session) and gt mail (async mailbox). Direct terminal output is prohibited for inter-agent communication per AGENTS.md.

Execution Mode

Continuous — Deacon runs perpetual patrol cycles. Witness runs per-rig patrol cycles. Polecats are event-driven (triggered by work appearing on hook). Mayor is interactive-loop (human-driven entry point).

Consensus / Merge Gating

Refinery uses Bors-style bisecting merge queue:

  1. Polecat calls gt done → MR queued
  2. Refinery batches MRs
  3. Verification gates run
  4. Failed MRs isolated; either fixed inline or re-dispatched to a Polecat
  5. Passing MRs merged to main

No Byzantine/gossip consensus — sequential pipeline with deterministic isolation of failures.

Multi-Model Support

The gt config agent list shows multiple runtimes (Claude Code, Codex, Copilot). Different Polecats can use different runtimes, enabling mixed-model teams. No automatic model-role routing — assignment is manual via rig/crew configuration.

Crash Recovery

Yes — core design principle. Worktree-backed hooks survive crashes. gt prime on session restart reloads context. Molecule root-only wisps prevent step re-execution; poured wisps have checkpoint recovery.

Scheduler

Config-driven capacity governor (settings/escalation.json and scheduler config) prevents API rate limit exhaustion. scheduler.max_polecats enables deferred dispatch with daemon.

08

Ui Cli Surface

Gas Town — UI and CLI Surface

CLI Binary

Binary: gt

Available via:

  • brew install gastown → signed binary at /usr/local/bin/gt
  • npm install -g @gastown/gt → Node.js wrapper that installs Go binary
  • go install github.com/steveyegge/gastown/cmd/gt@latest

The npm package (@gastown/gt, version 1.1.0) wraps the Go binary with a Node.js postinstall script (scripts/postinstall.js) that downloads the platform-appropriate binary. Not a thin wrapper over claude/codex — it is its own Go runtime.

Key subcommand surface: install, rig, crew, mayor, prime, nudge, mail, mol, hook, sling, convoy, done, escalate, seance, patrol, peek, config, up, gt.

Local Web Dashboard

Available via Docker Compose with DASHBOARD_PORT=8080. Provides monitoring view of the Gas Town workspace. The README references export DASHBOARD_PORT=8080 as optional configuration. The docker-compose.yml file is present in the repository.

Beads Viewer TUI (separate tool)

bv — read-only terminal TUI for graph analysis. Installed automatically by superbeads init and available standalone.

  • WARNING: bare bv launches interactive TUI — agents must use --robot-* flags only
  • bv --robot-triage — machine-readable ranked task output
  • bv --robot-insights — PageRank, betweenness, cycle detection

IDE Integration

No dedicated IDE plugin. Claude Code is used as the AI interface, launched via gt mayor attach or gt crew attach.

Observability

Session logs (.events.jsonl per agent session) — queryable via gt seance. Provides event replay capability for predecessor context queries.

Escalation log — escalation beads with severity labels + optional log action in escalation routing config writes structured escalation log.

Dolt audit trail — DoltHub's version-controlled database provides full history of convoy/molecule state changes with commit-level granularity.

Tmux — recommended for running multiple agent sessions side-by-side. gt mayor attach uses tmux for multi-pane agent management.

Proxy Architecture

The repository contains gt-proxy-client and gt-proxy-server in cmd/ — an HTTP proxy layer for agent-to-agent communication routing. Not documented in README; internal to the Gas Town communication stack.

Related frameworks

same archetype · same primary tool · same memory type

Claude-Flow / Ruflo ★ 55k
A6 Multi-agent orchestrator

Eliminates single-agent context limits and sequential bottlenecks by orchestrating fault-tolerant swarms of specialized AI agents…

Hermes Agent (NousResearch) ★ 168k
A6 Multi-agent orchestrator

Self-improving personal AI agent with closed learning loop, 7 terminal backends, and messaging gateway — not tied to any AI…

OpenCode ★ 165k
A6 Multi-agent orchestrator

Terminal-first AI coding agent with multi-model routing, native desktop app, and a typed .opencode/ configuration system for…

OpenHands ★ 75k
A6 Multi-agent orchestrator

Open-source AI software development platform (open-source Devin alternative) with Docker sandbox isolation, 77.6% SWE-bench…

DeerFlow ★ 70k
A6 Multi-agent orchestrator

Long-horizon superagent that researches, codes, and creates by orchestrating parallel sub-agents with isolated contexts in Docker…

oh-my-openagent (omo) ★ 60k
A6 Multi-agent orchestrator

Multi-provider AI agent orchestration for OpenCode: escape vendor lock-in by routing Sisyphus (Claude/Kimi/GLM) and Hephaestus…