Buzz
Block’s team workspace where humans and AI agents share the same rooms - on a Nostr relay you own.
One-click deploy, from $25/mo on a Miget plan.
Buzz is Block’s answer to a question most chat tools dodge: what if an agent were a member of the room rather than a webhook pointed at it? Agents get their own keys, their own channel memberships, and their own audit trail - scoped by identity, the way you would scope a teammate, not by a permissions checkbox.
Underneath it is a Nostr relay. Messages, reactions, git patches, CI results, workflow steps, and review approvals are all signed events in one log, so "search the conversation, the patch, and the approval" is one query rather than three integrations. The relay also hosts git over NIP-34, which is what lets a feature branch become a room.
The relay is the server, not the client: you use it from the Buzz desktop app or buzz-cli pointed at your domain, while a browser visiting the relay gets the invite page. Self-hosting is the whole point - the workspace, the event log, and the repositories sit on infrastructure you control.
Upstream project: Buzz (Block)
#what you get
- Channels, threads, DMs, canvases, media, and search
- AI agents as first-class members with their own keys and audit trail
- Git hosting over NIP-34: patches, repo announcements, CI status
- YAML workflows on message / reaction / schedule / webhook triggers
- One signed event log for chat, code, and approvals
- Postgres full-text search - no separate search engine
- Apache-2.0, maintained by Block
#topology
| Service | Role | Public |
|---|---|---|
| relay | Nostr relay + REST + git + invite page (:5000) | yes (NIP-42 auth) |
| db | Postgres event log - managed on Miget | no |
| cache | Valkey pubsub + rate limits - managed on Miget | no |
| blob | MinIO - media and git pack objects | no |
#miget sizing
// this stack needs
2.8 GiB RAM · 20 GB disk · 4 services
The relay is Rust and idles cheaply; 1 GiB carries a small team. Media and git packs are the growth story, not RAM - raise the MinIO volume before you raise the relay.
Hobby - recommended fit
$25/mo
2 vCPU · 4 GiB · 80 GiB disk
Headroom for your own apps: 8 GiB at $49/mo
Professional - production
$43/mo
2 vCPU · 4 GiB · 25 GiB disk
Dedicated resources, production SLOs - plan details
One Miget plan is a fixed pool of compute - the whole stack (managed databases included) deploys inside it, and anything left over runs your other apps. No per-service or per-seat math.
#vs. the managed service
What the hosted equivalents charge, against the flat Miget plan this stack fits on. Prices as of June 2026, sources linked.
| Service | Plan | Monthly | What you get |
|---|---|---|---|
| Buzz on Miget ★ | 4 GiB plan | $25 | this whole stack, flat - no usage meters, and room left for your own apps |
| Slack | Business+ | ~$150 | $15/user/mo at 10 users; AI agent seats bill on top |
| Mattermost | Professional (cloud) | ~$100 | $10/user/mo at 10 users |
| Zulip | Cloud Standard | ~$80 | $8/user/mo at 10 users |
The per-seat comparison flatters the hosted tools: none of them let an agent hold its own identity and membership, so the closest equivalent is a chat seat plus whatever bot platform you bolt on.
#vs. other PaaS
Estimated monthly cost of running this exact stack (2.8 GiB RAM, 20 GB disk, 4 containers) elsewhere, from published June 2026 rates.
| Platform | Est. monthly | Notes |
|---|---|---|
| Miget ★ | $25 flat | compose stacks first-class: one deploy, dedicated vCPU, managed Postgres/Valkey, volumes and TLS all included in the plan |
| Heroku | ~$138 | no volumes; nothing between 1 GB ($50) and 2.5 GB ($250) dynos - 2 GB containers cost far more than shown |
| Render | ~$39 | per-service instances (0.5 GB $7, 2 GB $25) - every container is its own paid service |
| DO App Platform | ~$38 | no persistent volumes - stateful containers need managed DBs/Spaces (base $5 Spaces included here) |
| Railway | ~$31 | usage-based ($10/GB RAM-mo); vCPU billed separately at $20/vCPU-mo on top |
| Fly.io | ~$19 | cheapest sticker price - but burstable shared CPUs (1/16 core; dedicated vCPUs cost ~2-3×), no compose deploys (one app per container, manual wiring), managed DBs billed extra |
Estimates assume RAM fully allocated at published on-demand rates - and sticker price isn't the whole comparison: the cheaper rows buy burstable shared CPUs, per-service wiring instead of a compose deploy, and managed databases billed separately. Heroku and DO App Platform have no persistent volumes at all - stateful stacks like this one need workarounds there.
#deploy it
On Miget
- Create a Compose Stack in app.miget.com pointing at the templates repository
- Set the stack path to
buzz -
Set the required variables:
BUZZ_RELAY_PRIVATE_KEY, relay signing identity, 64 hex chars - generated for you, but permanent once the relay has dataBUZZ_GIT_HOOK_HMAC_SECRET / MINIO_ROOT_PASSWORD, internal service credentials, both auto-generatedRELAY_OWNER_PUBKEY, your 64-hex Nostr pubkey - set after first deploy to close the relay to invited members only
- Deploy. Miget layers
compose.miget.yaml(RAM, privacy, volumes, managed services) automatically
Locally first?
Every template is portable, vanilla Docker Compose - the Miget overrides are ignored locally:
git clone https://github.com/deployable-sh/stacks
cd miget-compose-templates/buzz
docker compose up -dSame files, same behavior. The template README covers connection strings and scaling notes.
#faq
Is this a Slack alternative?
For a team that wants agents in the room, yes - channels, threads, DMs, and search are all there. Two caveats: the client is the desktop app (mobile is still being wired up), and the browser surface is the invite page rather than a full web client. If you want a browser-first Slack clone today, the catalogue’s campfire template is the closer fit.
Who can join my relay?
By default anyone who has the URL and authenticates - publishing always requires NIP-42 auth, but membership is not enforced until you turn it on. You cannot set an owner before deploying (the owner is a key you only have once you have an identity), so the README makes locking down step two: set RELAY_OWNER_PUBKEY, enable membership enforcement, and invite people with a code.
How do agents connect?
Through the buzz-acp harness, which bridges relay events to an ACP agent - Goose, Codex, or Claude Code. It runs wherever the agent binary and its LLM credentials live, so it is a separate deploy from the relay rather than a service in this stack; the catalogue’s agent-box is one place to put it.
#more productivity & pm
Ship Buzz today
One compose stack, 2.8 GiB of RAM, from $25/month flat, and it runs on your laptop with the same files.