mrkeyoor.com_
Tue 01 Sept 17:44 UTC
LLM Toolsevaluationupdated 27 Aug 2026

gastown review

Gas Town is a workspace manager for coordinating many coding agents across one or more Git repositories. It stores tasks, identities, handoffs, and recovery state outside an agent's chat so work can survive restarted sessions.

+94stars / 7d
Verdict

Our Gas Town run installed 651 packages and built in 108 seconds, but 27 of 75 Go test packages failed. Its persistent work model is a credible answer to 20-agent coordination, yet the setup and red suite make it a poor default for small teams. Adopt it only after a disposable-repository pilot proves hooks, database migrations, cleanup, and merge behavior on your exact platform.

We ran it

Lab card: what happened when we ran gastownScreenshot of gastown (github.com/gastownhall/gastown)
Install✓ · 125s651 packages
Build✓ · 108s
Tests✗ · 45s48 passed · 27 failed of 75 (go test)
Repo1563 files~488,579 lines of source · 23.5 MB · 11 CI workflows · Dockerfile

Answers from our run

Does gastown build from source?

Dependencies installed in 125 seconds (651 packages), and the build succeeded in 108 seconds. We cloned commit 649b832 into a clean Debian container with 3 CPUs and no project-specific setup.

Do gastown's tests pass?

Not all of them: 48 of 75 passed and 27 failed when we ran the project's own test command (go test). Some failures need services or credentials a bare container does not have.

Who should not use gastown?

Solo developers coordinating only 1 or 2 agents: the Mayor, Deacon, Witnesses, Refineries, Dolt, Beads, and tmux add substantial machinery.

What are the alternatives to gastown?

Ruflo, Named Tmux Manager, Beads. Our Gas Town run installed 651 packages and built in 108 seconds, but 27 of 75 Go test packages failed.

Setup2/5Many services and tools; install plus build took 233 seconds
Docs5/5Architecture, native, Docker, Windows, and runtime paths are explicit
Community4/517,794 stars with active August 2026 issue triage
Maturity2/5Core model is built out, but 27 test packages failed

Discussed on

  1. hnDoes Gas Town 'steal' usage from users' LLM credits to improve itself?253 points

Who it’s for

Teams already running several Claude Code, Codex, Copilot, or other coding-agent sessions.
Maintainers who need persistent task assignment, mailboxes, worktrees, and a merge queue.
Operators comfortable running tmux, Dolt, Beads, Git hooks, and background supervisors.
Large projects where agent restarts and cross-session handoffs are a recurring cost.

Who it’s NOT for

Solo developers coordinating only 1 or 2 agents: the Mayor, Deacon, Witnesses, Refineries, Dolt, Beads, and tmux add substantial machinery.
Teams requiring a green source suite: our run passed the build but 27 of 75 Go test packages failed.
Repositories where Git checkout must be side-effect free: open issue 4772 reports a committed Beads hook importing 460 old issues into a live database after checkout.
Native Windows users expecting the complete experience: the README recommends WSL for tmux-backed workflows and calls native shells best for minimal CLI use.
Operators who cannot isolate a local dashboard and bind-mounted workspace: the Docker guide says to treat the exposed dashboard as a trusted local-network surface.

Setup reality

Our sandbox installed 651 Go packages in 125 seconds, then built successfully in 108 seconds. Tests ran for 45 seconds and exited 1: 48 packages passed and 27 failed out of 75. The log tail showed build failures in packages including internal/tui/feed, internal/web, and internal/witness, without the underlying compiler messages.

Native setup needs Git, Go, Beads, sqlite3, ICU development headers, Dolt, tmux, and at least one coding-agent CLI. Full operation creates an HQ, project rigs, worktrees, databases, hooks, and long-running supervisors. Private GitHub rigs may also need gh authentication.

Docker Compose supplies most internal tools, but bind-mounts the HQ from the host and exposes a dashboard port. The README warns against sharing that host folder with a native Gas Town install. Windows source builds need MSYS2 for the ICU-backed CGO layer; WSL is preferred for full tmux workflows.

Gas Town stores agent work outside the chat session

Gas Town is designed for the point where several coding agents stop feeling like extra hands and start creating coordination work. A Mayor assigns tasks, project rigs contain workspaces, polecats act as workers, and git-backed hooks preserve identity and history after sessions end. Convoys group work, while Beads stores the underlying issues.

The larger system includes per-rig Witnesses, a town-wide Deacon, maintenance Dogs, and a Refinery that processes merge requests through verification gates. A scheduler can limit worker dispatch when providers impose rate limits. Session discovery can query prior agents for context. With 2 agents and one repo, a task file plus separate worktrees will usually be easier to understand.

Native setup brings at least 7 supporting tools

The current prerequisites name Git, Go, Beads, sqlite3, ICU development headers, tmux, and a coding-agent CLI. Dolt is also installed before the Linux and Windows paths, or supplied through Homebrew and Docker routes. gt install creates the headquarters, gt up starts long-lived services, and gt doctor --fix checks the result.

Platform details are unusually specific. macOS users are told to prefer Homebrew because a binary built with go install may be killed by Gatekeeper. Native Windows source builds need an MSYS2 environment for the ICU-backed CGO layer. Full tmux operation on Windows is directed toward WSL, with native shells described as a minimal CLI path. The Docker route supplies dependencies but still requires careful host-folder ownership and git identity settings.

What happened when we ran it

Our sandbox installed commit 649b832 in 125 seconds, pulling 651 Go packages. The build succeeded in 108 seconds. The checkout contained 1,563 files, about 488,579 source lines, and used 23.5 MB before dependencies. It had 11 CI workflow files, a Dockerfile, and a Compose file. There was no top-level tests directory, which is normal for Go projects that keep _test.go files beside source.

The Go test step ran for 45 seconds and exited 1. It reported 48 passed packages and 27 failed out of 75. The tail showed build failures for internal/tui/feed, internal/web, and internal/witness, along with other packages outside the displayed lines. Several packages, including internal/ui, internal/util, internal/wisp, and internal/workspace, passed.

The supplied tail does not include the compiler errors that caused those package builds to fail. We cannot attribute them to Go versions, system headers, generated code, or a product defect from this evidence. The useful finding is that installation and the main build completed in our unprivileged 3-CPU, 8 GB sandbox, while the full test command did not. A 27-package red result is too broad to dismiss as one flaky assertion.

Git hooks and databases make ordinary operations stateful

Persistence is Gas Town's selling point and its main risk. Project state lives across worktrees, hook branches, Beads data, and Dolt services. Open issue 4772 describes a repository containing committed .beads data and hooks. After Beads configured core.hooksPath, a later checkout reportedly imported 460 legacy issues into the live database without a visible prompt. The report was still marked for triage when fetched, so operators should test imported repositories before trusting normal checkout behavior.

Another open report, issue 4770, describes a Beads schema mismatch between a version embedded by Gas Town and the separately installed command. The reporter says databases were migrated beyond what that CLI would read. Back up the HQ, pin the related binaries together, and rehearse removal and restore with a disposable rig.

Docker reduces host dependencies while exposing trusted surfaces

The Compose path mounts an empty directory or existing HQ at /gt, builds the image, and starts the town inside a container. It supplies Go, Dolt, Beads, tmux, and other utilities. The dashboard port is published to the host. The README tells users to treat it as a trusted local-network surface and not point the mount at a workspace simultaneously used by a native installation.

That warning should shape deployment. Bind the dashboard conservatively, keep the HQ volume backed up, and separate test towns from working repositories. Private GitHub rigs may use gh auth login inside the container. Coding providers carry their own credentials and billing.

Multiple runtimes share state, though hooks differ

Claude Code is the default runtime, and the README lists presets for Codex, Gemini, Cursor, Copilot, Kiro, and several others. Claude uses settings hooks for mail and startup. Codex receives fallback commands after a session becomes ready and needs configuration to read CLAUDE.md as a project-document fallback. Copilot uses executable lifecycle hooks and autonomous mode, subject to an organization policy and paid seat.

Those differences mean a mixed fleet needs per-runtime acceptance tests. Confirm that each agent receives its assignment, writes to the intended worktree, reports completion, and survives a restart. Then test the Refinery against a deliberately failing merge request. Gas Town's abstractions are useful only when the runtime adapters preserve the same safety and handoff semantics.

August issue activity shows use, while the suite stays red

GitHub recorded 17,794 stars, 438 combined issues and pull requests, and a last push on August 19, 2026. Issue discussions continued through August 25. Latest release v1.2.1 was published on June 6 with precompiled binaries for Linux, macOS, and Windows. The release date alone looks older than the source activity, so it would be wrong to call the project abandoned.

Gas Town is one of the few projects attempting persistent multi-agent operations as an actual workspace system. The 233 seconds spent installing and building are less concerning than 27 failed test packages and open reports around hooks and schema state. Teams already suffering from agent coordination may justify a pilot. Everyone else should start with Beads or a tmux manager and add machinery only when simpler tracking has clearly failed.

Alternatives

ProjectWhat it isPick it when
Ruflo gh↗A coding-agent coordination system with swarm, memory, and workflow features.pick this instead when you want agent-swarm abstractions and integrations rather than Gas Town's worktree town model.
Named Tmux ManagerA tmux-focused TUI for spawning and coordinating Claude, Codex, and Gemini panes.pick this instead when visible pane management is enough and you do not need persistent issue databases or a merge refinery.
Beads gh↗The git-backed task and memory layer that Gas Town uses for work state.pick this instead when persistent agent tasks solve the problem without a full multi-agent workspace manager.

What people are saying

  1. [github-trending] gastownhall/gastown

Sources

  1. Gas Town README
  2. Gas Town v1.2.1 release
  3. Gas Town Docker guide
  4. Beads checkout import issue
  5. Beads schema mismatch issue

More llm tools reviews

rig · open-knowledge · graphiti · cve-mcp-server · minimind · SillyTavern · the whole board →