Block Buzz & Wasp: Two Agent-Ready GitHub Repos

> **TL;DR:** This week's two standout repositories both treat AI agents as permanent residents rather than add-ons. Block's Buzz (24,524 stars, Rust, Apache-2.0) is a self-hostable workspace where humans and agents share the same rooms on a Nostr relay you own, with every message, workflow step, review approval and git event stored as a signed event. Wasp (18,662 stars, TypeScript, MIT) is a Rails-like framework for React, Node.js and Prisma whose declarative config is compact enough that a coding agent can scaffold and deploy a working app from it.

Key Takeaways

- Buzz is a self-hostable, Apache-2.0 workspace written in Rust where people and AI agents post into the same rooms — currently at 24,524 stars. - Buzz is built on a Nostr relay: messages, reactions, workflow steps, review approvals and git events are all signed events, so the audit trail is cryptographic rather than a vendor's chat log. - In the setup shipping today, one relay URL maps to exactly one Buzz community, and all tenant-observable state under that URL is community-local. - Wasp (18,662 stars, MIT) abstracts auth, background jobs, RPC, email sending, end-to-end type safety and one-command deployment behind declarative code — a small, legible surface for agents to target. - Wasp explicitly avoids provider lock-in: you can deploy a Wasp app anywhere, which matters when the code was written by a machine you may want to migrate off.

Two repositories are worth your attention this week, and they answer the same question from opposite ends of the stack: what does software look like when AI agents are permanent residents rather than guests? [block/buzz](https://github.com/block/buzz) answers it at the workspace layer — a self-hostable room where people and agents write to the same signed event log. [wasp-lang/wasp](https://github.com/wasp-lang/wasp) answers it at the codebase layer — a declarative full-stack framework compact enough that an agent can hold an entire application in its head and still ship it. Buzz currently sits at 24,524 stars; Wasp at 18,662.

Neither project is a model, and that is precisely why they are interesting. The past few months of releases have been dominated by capability announcements — bigger context windows, better video, faster voice, the kind of run we covered in [AI Launches: Gemini Robotics 2, Seedance 2.5, Grok Voice](https://speka.info/blog/ai-launches-gemini-robotics-2-seedance-2-5-grok-voice). What has lagged badly is the plumbing: where agents live, what they are allowed to touch, and what code they can realistically finish. These two repos are plumbing, and both are among the most-starred open-source attempts at it.

Buzz — a workspace where humans and agents share the same room

**What it is.** Buzz is a self-hostable workspace, published under Block's GitHub organisation, that GitHub's own description labels "a hive mind communication platform." The README frames it more plainly: a place where humans and agents build together, on a relay you own. It is written in Rust, licensed Apache-2.0, and organised around a handful of concerns the README names directly — Vision, Sovereign, Forge, Agents, Architecture and Releasing. Functionally, think of a team chat workspace in which the participants who do the work are not all people, plus a management surface for the coding agents you have running.

The part that separates it from a chat app with bots bolted on is the transport. Buzz is a Nostr relay. Every message, every reaction, every workflow step, every review approval and every git event is a signed event on that relay. Nothing is a row in someone else's database that happens to be rendered as a conversation.

The addressing model: one URL, one community

A Buzz community is simply the workspace a user reaches by URL. In the single-relay setup that ships today, the relay URL selects exactly one community — one deployment, one room set, one tenant. A hosted operator can serve many communities behind many domains or subdomains, but the client-facing rule does not change: the URL is authoritative for the workspace, and all tenant-observable state under that URL is community-local.

That is a small paragraph in a README and a large architectural commitment. It means isolation is a property of the address rather than a permissions check somewhere in application code, and it means self-hosting is the default shape of the system instead of an enterprise tier grafted on later.

**Why it matters.** Most teams running agents today are running them somewhere unaccountable — a terminal, a hosted dashboard, a Slack channel where a bot posts summaries of work nobody can reconstruct. Buzz makes the record the primitive. If an approval, a workflow step and a git event are all signed events on a relay you operate, then "who authorised this change" and "what did the agent actually do" are queries against your own log, not a support ticket. For anyone deploying agents that write code, move money-adjacent data or touch customer records, that distinction is the whole ballgame.

The sovereignty angle compounds it. Apache-2.0 plus self-hosting plus an open relay protocol means the failure mode of the vendor disappearing is an inconvenience rather than an extinction event. Rust is a sensible pick for something meant to sit in the path of every message a team sends.

Two honest caveats. First, the shipping configuration is one relay to one community — multi-tenancy is an operator's job right now, not a checkbox. Second, running your own relay is real operational work; this is infrastructure you adopt, not a SaaS you sign up for. There is no verified pricing, hosted tier or SLA to evaluate, because the repository is the product.

**Who it's for.** Teams already running more than one coding agent and losing track of what they did; engineering orgs with audit or data-residency requirements that rule out a hosted agent console; anyone who has read a [self-improving agent architecture](https://speka.info/blog/prime-agent-prime-intellects-self-improving-rlm) and concluded that the missing piece is not autonomy but supervision.

**GitHub:** [block/buzz](https://github.com/block/buzz) — Rust, Apache-2.0, 24,524 stars at the time of writing.


Wasp — the batteries-included framework agents can actually finish

**What it is.** Wasp — short for Web Application Specification — is a Rails-like full-stack framework for React, Node.js and Prisma. You describe the application in declarative code, and Wasp generates and wires the parts that normally eat the first week of a project: authentication, background jobs, RPC between client and server, email sending, end-to-end type safety, and deployment behind a single CLI command. It is TypeScript, MIT-licensed, sits at 18,662 stars, and its documentation lives at [wasp.sh](https://wasp.sh).

The project's own pitch is that expressiveness buys you speed: a production-ready app from scratch in very few lines of concise, consistent, declarative code, with correspondingly less boilerplate to maintain, understand and upgrade. It also makes a point of not trapping you — a Wasp app deploys anywhere, with no lock-in to a specific provider.

Why a declarative framework is agent-shaped

The reason Wasp keeps surfacing in AI-assisted development is not that it markets itself as an AI framework. It is that declarative configuration is the format agents handle best. A coding agent asked to build, say, a simple CRM against a conventional stack has to produce and keep consistent a sprawl of auth middleware, session handling, job queues, API route definitions, client fetch layers and deployment config — and every one of those is a place to hallucinate a plausible-but-wrong incantation. Against Wasp, most of that collapses into declarations the framework expands correctly by construction.

The secondary benefit is context economy. A small, consistent surface means less of the window spent re-reading boilerplate the agent wrote an hour ago — which matters more than raw model quality once you are paying per token, a calculus we dug into in our look at [free model routing](https://speka.info/blog/omniroute-free-ai-model-router-unlocks-claude-opus-4-6). And end-to-end type safety gives the agent a compiler-shaped feedback loop instead of a runtime surprise.

**Why it matters.** The bottleneck in agent-built software is rarely the interesting logic; it is the seventy percent of an application that is undifferentiated wiring. Frameworks that absorb that wiring convert an agent from a code generator into something closer to a product builder. The MIT licence and the explicit no-lock-in stance also mean the resulting app is portable — worth caring about when the codebase was largely written by a machine you may want to swap out later.

**Who it's for.** Solo developers and small founding teams who want a deployable full-stack app quickly; anyone pointing a coding agent at a greenfield internal tool, dashboard or CRM; React and Node teams tired of rebuilding auth for the ninth time. If your stack is not React/Node/Prisma, this is not for you — Wasp's power comes from being opinionated.

**GitHub:** [wasp-lang/wasp](https://github.com/wasp-lang/wasp) — TypeScript, MIT, 18,662 stars at the time of writing.


The thread connecting them

Put side by side, Buzz and Wasp describe a complete working environment for agent-assisted teams that nobody has yet packaged as one product. Buzz is where the work is coordinated and recorded; Wasp is what the work is built with. Both are open-source, both are self-owned by design, and both make the same bet: that the constraint on useful agents is no longer intelligence but legibility — of the record on one side, of the codebase on the other.

How to evaluate them this week

- **Start with the licence and the ops cost.** Apache-2.0 and MIT are both permissive; the real difference is that Buzz asks you to run a relay and Wasp asks you to accept an opinionated stack. - **Test Buzz on a low-stakes room first.** Point one agent at it, do a week of real work, then read back the event log and check whether it actually answers "what happened." - **Test Wasp with the app you keep not building.** The internal tool nobody has time for is the ideal benchmark — if an agent can carry it to a deployed URL, the framework has earned its slot. - **Watch the multi-community story on Buzz.** One relay, one community is the shipping shape today; how that evolves determines whether it stays a team tool or becomes a platform.

More of the week's most consequential repositories, with the same what-it-is, why-it-matters, who-it's-for breakdown, live in our [GitHub Weekly Wins](https://speka.info/github-weekly-wins/) archive.

Frequently Asked Questions

What is Block's Buzz?

Buzz is a self-hostable workspace, published under Block's GitHub organisation, where humans and AI agents share the same rooms. GitHub describes it as "a hive mind communication platform"; it is written in Rust and licensed Apache-2.0.

How does Buzz store messages and agent activity?

Buzz is a Nostr relay. Every message, reaction, workflow step, review approval and git event is stored as a signed event on a relay you own, which makes the activity record cryptographically verifiable rather than a vendor-held chat log.

Can one Buzz deployment host multiple communities?

In the single-relay setup that ships today, the relay URL selects exactly one community. A hosted operator can serve many communities behind different domains or subdomains, but the URL always determines the workspace and all tenant-observable state under it is community-local.

What is Wasp used for?

Wasp is a Rails-like full-stack framework for React, Node.js and Prisma. You write declarative code and Wasp handles auth, background jobs, RPC, email sending, end-to-end type safety and single-command deployment.

Why do people pair Wasp with AI coding agents?

Because declarative configuration removes most of the boilerplate where agents make mistakes, and the small, consistent surface costs far less context to work with. The framework expands the declarations correctly, so the agent only has to get the app's intent right.

Are Buzz and Wasp free and open source?

Yes. Buzz is Apache-2.0 licensed and Wasp is MIT licensed, and both are fully open on GitHub. Wasp additionally states there is no provider lock-in — you can deploy a Wasp app anywhere.

Sources

- https://github.com/block/buzz - https://github.com/wasp-lang/wasp