Gastown: A Minimalist Go Tool for Multi-Agent Workspaces

If you're working with multiple AI agents or microservices that need to coordinate, you've probably felt the pain of managing their communication, state, and boundaries. Enter Gastown — a minimal Go tool that helps you define and run multi-agent workspaces with zero friction.

Built by a solo developer who clearly values simplicity, this project cuts through the noise. No bloated frameworks, no steep learning curve. Just a clean approach to agent orchestration using Go's concurrency model.

What It Does

Gastown lets you define a workspace where multiple agents (Go functions, HTTP services, or even external processes) can communicate through channels. Think of it as a lightweight message bus for your agents, with built-in lifecycle management and error handling.

The core idea is simple: you declare your agents, wire them together, and Gastown handles the plumbing. Agents can send messages to each other, share state via a key-value store, or trigger actions when specific events happen.

It's essentially a supervisor for agent-based workflows, but without the cognitive overhead of traditional orchestration tools.

Why It's Cool

A few things stand out about Gastown:

Minimal API — The whole thing is under 500 lines of Go code. You're not fighting abstractions. You write regular Go functions, register them as agents, and go.

Built on channels — Since it's Go, Gastown leverages goroutines and channels natively. This means message passing is concurrent, safe, and fast. No external dependencies required.

Hot reload for agents — You can add or remove agents at runtime without restarting the workspace. That's huge for debugging or dynamic workflows.

Pluggable transports — By default, agents talk via in-process channels. But you can swap in Redis, NATS, or even simple HTTP as the transport layer. The interface is dead simple.

Debugging built-in — The tool includes a verbose logging mode and a web UI for visualizing agent connections. Perfect for when your multi-agent system starts acting like a dysfunctional coworker.

How to Try It

Getting started is dead simple. Go 1.21+ required.

# Clone the repo
git clone https://github.com/gastownhall/gastown.git
cd gastown

# Run the example
go run examples/simple/main.go

The repo includes examples for:

• Hello World with two agents
• Agent with shared state (key-value store)
• Agent that calls an external API
• Error propagation between agents

Want to define a custom agent? Just implement the Agent interface:

type MyAgent struct{}

func (a MyAgent) Handle(msg Message) (Message, error) {
    return Message{Type: "reply", Payload: "Hello, world!"}, nil
}

Then register it:

workspace := gastown.New()
workspace.Register("greeter", MyAgent{})
workspace.Start()

That's it. No YAML files, no complex configs, no learning Kubernetes to manage three goroutines.

Final Thoughts

Gastown isn't trying to be the next Airflow or Kubernetes for agents. It's a focused tool for when you just need to get multiple Go components talking to each other without overhead.

If you're building something with AI agents, micro-ORC pipelines, or just want a clean way to coordinate goroutines — give it a try. The dev behind it clearly understands that sometimes less is more. And in a world of overengineered agent frameworks, that's refreshing.

Found via @githubprojects