Buzz Is Slack on AIroids

Block launched Buzz on July 21 as an open-source workspace with team chat and signed work records for people and agents. Buzz can run Codex and Claude Code, and its Apple Silicon build lets members lend local model compute. A team assigns work and sees who acted. Restart-safe delegation and private repository reads remain unfinished. Buzz is Slack on AIroids.

Agents join the same rooms

Buzz connects runtimes through the Agent Client Protocol (ACP) over stdio. Codex and Claude Code need ACP adapters. If either runtime creates a Git worktree or delegates to another agent, that runtime supplies the tool. Buzz queues the room message and records the reply. Its pool can process separate channels at once, but every process in one pool uses the same Buzz identity.

Each agent gets a key

Buzz gives each person and agent a Nostr key. In its draft owner-agent scheme, an owner signs an attestation for an agent key, and the agent signs its own events. The attestation records provenance; relay membership still controls access. Block states the rule: “authorization does not erase authorship.”

1. Human identity Human key

   Signs the attestation
   attests to →
2. Agent identity Agent key

   Signs its own work
   produces →
3. Signed activity Work events

   Chat and code activity
   records →
4. Audit trail Work record

   Signed event history

Buzz binds each accepted event to the authenticated key and verifies its channel access.

A shared bot account can hide which agent announced or approved a change. Buzz keeps each agent's events separate across chat and Git. If someone steals a key, an admin can remove its relay access without changing the owner's account.

The agent key does not change when its model or harness changes. Buzz should show those changes, or readers may assume the same software still runs it.

The controls are unfinished

Buzz's workflow schema accepts schedule and HTTP webhook triggers. Owner attestation remains a draft Nostr extension that records provenance, while relay membership controls access. Human approval uses a separate workflow step that cannot yet resume a run; Issue #2376 remains open and tracks the missing support.

Some work stays outside the event log

Buzz signs chat and Git events. Git objects live in another store, and voice frames never enter the event log. A reviewer can see which key announced a push or approved a change. Teams must check linked objects and later jobs elsewhere.

Models still lose context

Buzz keeps chat and agent work in one record. After a restart, an agent can search it, but only selected room history and memory enter the prompt. The relay may hold six months of chat while the model sees a small part of it.

Buzz searches stored events with Postgres full-text search, which matches exact terms and may miss paraphrases. The agent must choose a query and inspect the results.

Buzz loads core memory only when a new ACP session starts. Named memories require a lookup, and a long session may keep an old core record. Named memories stay out of the prompt until the agent fetches them.

Room history is shared. Buzz keeps each memory note with one agent-owner pair. A team can pass facts through chat; Buzz has no common team memory store.

ACP prompts carry full event IDs and tags. During a long native session, a handoff replaces old history with a model-written summary. After ten handoffs, Buzz drops older turns.

Stored history helps only when an agent loads it.

When Buzz runs Codex or Claude Code through ACP, each runtime controls its own context and compaction. Buzz can track reported token use and add room history. The repository has no benchmark that compares token use with and without Buzz.

Activity is not a terminal

Buzz can show a parsed activity feed or raw ACP JSON-RPC frames. A local owner can stop the current turn. The view cannot attach to the agent's terminal or accept terminal input. Buzz can open a separate shell at the project checkout, but that shell does not join the running agent process.

Buzz's native agent keeps sessions in memory and advertises loadSession: false. A restarted process starts a new ACP session and rebuilds context from the room and memory tools. It also waits for one non-streaming model response per round. Codex and Claude Code keep their own session rules behind their ACP adapters.

Buzz restarts crashed agent processes

The ACP layer sends one prompt at a time per channel and batches later events. If an agent process crashes, Buzz starts a new one. These controls do not replay work missed while the agent was offline.

Members can lend a local model

Buzz's Apple Silicon release build includes shared compute through MeshLLM. A member picks a local model and turns on Share this machine. Buzz then offers that model to other members through a local OpenAI-compatible endpoint. Signed discovery data binds the member key to the serving node, and current community membership controls which nodes may serve.

The runbook traces the built-in Fizz path from desktop to buzz-acp, buzz-agent, MeshLLM, and a member model. Shared compute acts as an LLM provider. It does not move a Codex or Claude Code harness to another member's machine.

MeshLLM carries inference over direct QUIC or encrypted Iroh relays; the Buzz relay handles membership and discovery. The local provider caps an answer at 4,096 tokens and turns off model thinking. Buzz's code says this keeps output inside smaller local-model context windows. That choice favors short work. Buzz has no result that compares it with the same model outside Buzz.

Buzz calls Mesh a compute commons. Members who trust one relay lend spare hardware to each other, with no API key or cloud bill. Buzz plans a community compute pool. The X post adds a second idea: a market where agents or teams pay for work.

Nostr can move the invoice. Buzz cannot price the job

1. Shipped Signed key

   Names the buyer, agent, or host
   signs →
2. Missing link Job quote

   Binds scope, model, price, and deadline
   starts →
3. Partial Work record

   Links the result and agreed use
   releases →
4. Missing path Payment

   Settles or cancels the invoice

Buzz can record two kinds of use. When an agent runtime reports use, its NIP-AM publisher stores an encrypted record with token counts and an estimated cost. A serving Mesh node also tracks requests, output tokens, and remote use. These records do not form one bill. The node keeps aggregate counters in local runtime status; neither record binds a member, one request, a price, and a payment. Buzz's NIP-AM spec calls its cost estimate advisory.

Funding shared hardware needs fewer rules than paid work

A Buzz room could use NIP-75 to fund one GPU, then use NIP-57 to split tips among its hosts. That stays close to Buzz's current trust group: the community funds capacity, then membership grants use. It needs a wallet and UI, but no meter for each turn. Open issue #265 already lists NIP-57 zap events as relay work.

A fixed price for an accepted job fits Buzz sooner than a token bill. Its Mesh counters cannot tie remote tokens to one member. NIP-90 sketches a request, bid, result, and BOLT11 invoice. Its text-generation job can name a model and cap output tokens. The Nostr project marks NIP-90 unrecommended and leaves payment timing open. Buzz also reserved its own job kinds because delegation needs owner authorization chains. Buzz's relay does not accept those job kinds.

NIP-47 could give an app or agent a separate wallet key, a wallet-set spending cap, and a way to make, pay, or hold an invoice. Buzz would still need a rule for when the parties settle or cancel it. NIP-57 can attach a tip receipt to a signed event and split the tip among keys. Buzz supports neither path. Its relay rejects unknown event kinds, including NIP-57 receipt kind 9735, and its published NIP list omits NIP-57.

Buzz has identity and usage records. It has not joined them into a price, bill, or payment.

The X post's “instant zero-fee” claim goes too far. routing nodes may charge a base fee and a rate. Payments can also fail when routes time out or lack capacity. NIP-57 warns that a zap receipt does not prove payment; the client trusts the wallet that signed it. A settled invoice still cannot show which model ran, whether the host counted tokens well, or whether the result met the job.

The near bet is a funded compute pool inside one Buzz community. The far bet is an agent market across relays. An agent can keep one key, but its work history needs relay replication or a cross-relay index. Buzz has neither. Paid work also needs private prompts, budget controls, and a rule for bad results. Nostr supplies signed identity; Lightning moves the money. Buzz would still need the work and payment rules.

Git review stays in Buzz

Buzz runs a Git server. Its Projects preview shows pull requests and review decisions. Teams can host Git without GitHub, while runners and security tools remain outside Buzz.

One relay runs each community

Block calls Buzz decentralized because it uses Nostr keys and signed events. One relay holds each community's record, and Buzz has no peer or relay replication. A team can run its own relay and reuse its keys on another server. Each community still depends on one operator for service and access.

A self-hosted team controls its relay. Remote model providers may still receive prompts. The team must also run four persistent data volumes and own upgrades and recovery.

Try one project room

Wait when work needs reliable approval or offline delivery, or when code must stay private.

Run the same tasks in Buzz and one direct agent runtime. Hold the inputs, model, token limit, and pass condition fixed. For shared compute, use the same local model on both paths. Measure time to the first visible step, completion time, tokens, extra messages, and task result. Stop if Buzz adds cost without cutting coordination work.

Low-risk work is the current limit

The agent account gives each agent durable authorship; shared compute lets members lend a local model. Nostr could fund that pool or turn signed jobs into paid work, but Buzz has not joined identity, use, and payment. Keep merge rights and secrets outside Buzz until the restart and private-read tests pass.