Build a Multi-Agent Collaboration Room

Run two AI agents with cryptographic identities in a self-hosted Buzz workspace.

Introduction

30 Second Summary

Think about how teams coordinate work today. Now imagine your AI agents doing the same thing: sitting in a shared room, responding to each other, and signing every action so you know exactly who did what.

In this project, you will set up a local Buzz workspace where you collaborate alongside two AI agents in shared channels, watch them hand off work to each other, and inspect a tamper-evident audit trail that proves which agent authored every message.

What You'll Build

You will @mention an agent in a channel, watch it respond, then ask a second agent to review the first agent's work and see the collaboration happen in real time with cryptographic proof that ties every action to the identity that performed it.

By the end of this project, you'll have:

A self-hosted workspace where you @mention AI agents in channels and they respond with signed messages tied to their own cryptographic identity.
Two agents from different providers (Goose and Claude Code) collaborating in the same room, building on each other's output without human intervention.
A cryptographic audit trail where every message carries a distinct Schnorr signature proving exactly which agent or human authored it.
Secret Mission: an automated YAML workflow that triggers agent coordination on a schedule or message event, removing the need for manual @mentions.

Are there any prerequisites?

You need Docker installed and running, macOS with Homebrew, and an authenticated Claude Code CLI (either a subscription or an Anthropic API key).

Step 1 walks you through cloning the Buzz repo and installing the agent runtimes. No prior experience with Buzz or agent protocols is needed.

Before We Start

Before We Start...

Before we dive in, let's lock in what you're about to build and why it matters. This is your chance to commit to the goal before any hands-on work begins.

Set Up Buzz, Goose, and Claude Code

For humans and AI agents to collaborate in one room, you need three layers of infrastructure: a relay that routes and stores signed messages, agent runtimes that give each AI its own identity on the relay, and a desktop app where you interact with the workspace.

In this step, you will clone and build the Buzz relay from source, install the Goose CLI and the Claude Code ACP adapter, then launch the workspace and create your account.

In this step, get ready to:

Clone, build, and launch the Buzz relay and desktop app.
Install the Goose CLI and Claude Code ACP adapter.
Verify everything runs and create your workspace account.

Verify Docker and clone the Buzz repository

Buzz uses Docker to run its backing services (Postgres, Redis, MinIO) and Hermit to pin the exact toolchain versions (Rust, Node, pnpm) so you do not need to install them manually.

Confirm Docker is running by running this command:

docker info

You should see a block of server information printed to your terminal, including storage driver and Docker version. If you see an error about the Docker daemon not running, open Docker Desktop and wait for it to start.

Seeing "Cannot connect to the Docker daemon"?

Open Docker Desktop from your Applications folder and wait until the whale icon in the menu bar stops animating. Then try docker info again.

help me troubleshoot Docker not starting on my Mac

Move to your Desktop by running this command:

cd ~/Desktop

Clone the Buzz repository and move into it by running this command:

git clone https://github.com/block/buzz.git && cd buzz

You should see Git downloading the repository. Once complete, your terminal prompt will be inside the buzz directory.

Activate the Hermit toolchain by running this command:

. ./bin/activate-hermit

You should see a confirmation message that the Hermit environment has been activated. Your shell prompt may also change to show a shell emoji.

What does this command do?

Sourcing activate-hermit adds Buzz's pinned versions of Rust, Node, pnpm, and other tools to your shell's PATH. This means you do not need to install these tools separately. Hermit downloads them automatically when first needed.

Run the one-time setup and build by running this command:

just setup && just build

What does this do behind the scenes?

This is the longest command in the project. It starts Docker services (Postgres, Redis, MinIO), runs database migrations, installs desktop dependencies, and compiles the entire Rust workspace.

Expect it to take 3-5 minutes on first run. You will see a stream of compilation output. Wait until your terminal prompt returns before continuing.

When the command finishes, your terminal prompt returns with no errors. The Buzz workspace is now built and ready to launch.

Build failing with a Rust or Docker error?

Make sure you activated Hermit (the . ./bin/activate-hermit step above). Without it, your shell cannot find the correct Rust version.

If Docker services fail to start, confirm Docker Desktop is running with docker info and try again.

help me debug the Buzz build failing

Install the agent runtimes

Each AI agent needs its own runtime. Goose is Block's open-source agent CLI. The Claude Code ACP adapter wraps Anthropic's Claude Code so it can speak the Agent Client Protocol over stdio.

Install the Goose CLI by running this command:

brew install block-goose-cli

Homebrew downloads and installs Goose. You should see the usual Homebrew output ending with a success message.

Install the Claude Code ACP adapter globally by running this command:

npm install -g @agentclientprotocol/claude-agent-acp

npm installs the adapter package. You should see output confirming the package was added.

Verify both tools are installed by running these commands:

goose --version
claude-agent-acp --version

Each command should print a version number. The exact version does not matter as long as you see a number and not an error.

Command not found after installing?

If goose --version fails, try opening a new terminal tab and re-activating Hermit (cd ~/Desktop/buzz && . ./bin/activate-hermit). Homebrew may need a new shell session to update PATH.

If claude-agent-acp --version fails, check that the npm global bin directory is on your PATH. Run npm bin -g to find the directory and confirm it is in your PATH.

help me fix the agent runtime installation

Launch the Buzz relay and desktop app

Everything is built. Before you run the next command, what do you think will happen when you launch the development environment?

Start the relay and desktop app by running this command:

just dev

What does just dev do?

This command builds the agent tools, starts the Buzz relay on ws://localhost:3000 in the background, and launches the Tauri desktop app. The relay process is automatically killed when you quit the app or press Ctrl+C.

This terminal is now occupied by the running process. For later steps, you will open new terminal tabs. Keep this one running.

The Buzz desktop app opens automatically. You should see a welcome screen prompting you to create your account or community.

Follow the on-screen prompts in the desktop app to create your account.
Once signed in, confirm you can see your workspace with the relay connected at ws://localhost:3000.

Desktop app not opening?

If the app does not appear after a minute, check the terminal for errors. A common cause is a port conflict. If you see a message about port 3000 already in use, stop whatever is using that port (lsof -i :3000 to find it) and run just dev again.

help me get the Buzz desktop app to launch

Your relay infrastructure is running and both agent runtimes are installed. Next up, you will create a collaboration channel and see your first signed messages in action.

Create Your Collaboration Channel

Your relay is live, your account is created, and both agent runtimes are standing by. Before agents can join, you need a shared room where humans post tasks and agents respond.

In this step, you'll create your first channel in the Buzz desktop app and post a message to confirm the relay is working. This channel becomes the collaboration space where Goose and Claude Code will later join as first-class members.

In this step, get ready to:

Create a new channel in the Buzz desktop app with a name and description.
Post a test message and confirm your cryptographic identity is attached.
Explore the workspace search and locate your public key in settings.

Create a new channel in the Buzz desktop app

Channels in Buzz are rooms where members collaborate. You'll create one now so agents have a shared space to join in the next steps.

In the Buzz desktop app, look at the left sidebar.
Click the + button next to the channels section header (or use the channel browser).
Enter agent-room as the channel name.
Enter Multi-agent collaboration space as the description.
Leave visibility set to open and click Create.

Your new channel appears in the sidebar and opens automatically.

What is a channel in Buzz?

A channel is a persistent room on your relay where any member (human or agent) can post messages, share files, and collaborate. Every message posted to a channel is stored as a signed event on the relay, creating a tamper-evident record of who said what.

Don't see the channel?

Make sure your relay is still running. Switch to the terminal where you ran just dev and confirm there are no error messages.

If the desktop app lost its connection, try quitting and relaunching it. The relay should still be running on ws://localhost:3000.

Why can't I create a channel in the Buzz desktop app?

Post a test message and confirm your identity

Every message in Buzz is cryptographically signed by the author's keypair. Before you bring agents in, confirm that your own messages carry your identity.

What do you think will identify you as the message author? A username, an email, or something else?

Click into the agent-room channel's message input at the bottom.
Type Hello from a human teammate! and press Enter to send.

Your message appears in the channel with your Nostr public key (or your display name) shown as the author. This is your cryptographic identity on the relay.

Why a public key instead of a username?

Buzz uses Nostr keypairs for identity. Every event (message, reaction, file upload) is signed with the author's private key and verifiable with their public key.

This means no central authority decides who you are. Your keypair IS your identity, and signatures prove authorship without trusting a server.

Explore search and find your public key

Two workspace features will be useful throughout the project. Confirm they work now.

Press Cmd+K (macOS) or Ctrl+K (Windows/Linux) to open the search bar.
Type agent-room and confirm your channel appears in the results.
Press Escape to close search.
Open Settings (click your avatar or profile icon in the bottom-left of the sidebar).
Locate your public key displayed on the profile page. Note it down or keep this page accessible.

You'll compare this key against agent keys later when inspecting the audit trail.

Keep your public key handy

In Step 5 you'll query signed events and compare public keys to prove which identity authored each message. Knowing your own key makes it easy to distinguish your messages from your agents' messages.

Search not finding your channel?

Search indexes may take a moment to update after creating a new channel. Wait a few seconds and try Cmd+K again.

Why isn't Buzz search returning my new channel?

Your collaboration room is ready and your identity is confirmed. Next up, you'll bring Goose into this channel as a first-class member with its own cryptographic keypair.

Bring Goose Into the Room

Your workspace is live, your channel has its first message, and the relay is proven to work. Now it's time to bring in an AI agent as a first-class member of the room.

Goose is an open-source AI agent from Block. In this step, you'll mint a cryptographic keypair that gives Goose its own identity, register it on the relay, and launch it as a channel member. When Goose responds, its messages carry its own Schnorr signature, not yours.

In this step, get ready to:

Generate a cryptographic keypair for Goose and register it on the relay.
Launch the Goose ACP harness so it can listen for @mentions.
Add Goose to your channel and watch it respond with its own signed identity.

Generate a keypair for Goose and register it on the relay

Every agent in Buzz needs its own Nostr keypair. The keypair is the agent's cryptographic identity. Messages signed with it prove exactly which agent authored them.

Open a new terminal tab and navigate to your buzz directory.
Activate the Hermit toolchain by running:

. ./bin/activate-hermit

Generate a keypair for Goose by running:

cargo run -p buzz-admin -- generate-key

You should see a public key and a secret key printed as hex strings.

Save your keys immediately

The secret key is not stored anywhere and cannot be recovered. Copy both keys to a text file or notes app right now. Label them Goose public key and Goose secret key.

The relay also needs its own signing key so it can publish membership events. You'll generate a second keypair for the relay.

Run the same command again to generate a relay signing keypair:

cargo run -p buzz-admin -- generate-key

Save this second pair separately. Label them Relay public key and Relay secret key.

Why two separate keypairs?

Goose's keypair is the agent's identity for signing messages. The relay's keypair is used to publish administrative events like membership records (kind:13534). Keeping them separate means the relay's authority and the agent's identity never overlap.

Now you need to tell the relay about its signing key. This requires editing the .env file in your buzz directory.

Open the .env file in your buzz directory with your editor.
Find the line containing BUZZ_RELAY_PRIVATE_KEY (it will be commented out with a #).
Uncomment the line by removing the # and set its value to your relay secret key (the hex string you just saved).
Save the .env file.

The relay needs to be restarted to pick up the new signing key.

Switch to the terminal where just dev is running and press Ctrl+C to stop it.
Restart the relay and desktop app by running:

just dev

The relay restarts on ws://localhost:3000 and the desktop app reopens. Your channel and test message are still there because the data lives in Postgres.

Now register Goose's public key as a relay member so it can read and publish messages.

Register Goose as a relay member by running the following command, replacing the placeholder values with the keys you saved:

BUZZ_RELAY_PRIVATE_KEY=your-relay-secret-key cargo run -p buzz-admin -- add-member --pubkey your-goose-public-key

What does this command do?

The BUZZ_RELAY_PRIVATE_KEY prefix passes the relay's signing key to the admin tool for this single command. The add-member subcommand publishes a kind:13534 membership event, telling the relay that this public key belongs to an authorized member.

You should see confirmation output indicating the membership event was published.

Seeing a connection or signing error?

Make sure just dev finished starting before running the add-member command. Wait a few seconds after just dev logs that the relay is ready.

Double-check that the relay secret key in your command matches the one you set in .env. A mismatch means the admin tool signs with a different identity than the relay expects.

help me debug a signing or connection error when running buzz-admin add-member

Launch the Goose ACP harness

The ACP harness is the bridge between the relay and Goose. It listens for @mentions on the relay, forwards them to Goose, and sends Goose's replies back as signed messages.

Open another new terminal tab, navigate to your buzz directory, and activate Hermit:

. ./bin/activate-hermit

Set the environment variables and start the harness by running these commands, replacing your-goose-secret-key with the Goose secret key you saved earlier:

export BUZZ_PRIVATE_KEY="your-goose-secret-key"
export BUZZ_RELAY_URL="ws://localhost:3000"
export GOOSE_MODE=auto
export BUZZ_ACP_RESPOND_TO="anyone"
cargo run --release -p buzz-acp

What do these environment variables do?

BUZZ_PRIVATE_KEY is the secret key that authenticates Goose on the relay and signs its messages.
BUZZ_RELAY_URL tells the harness where to connect.
GOOSE_MODE=auto lets Goose respond without manual approval.
BUZZ_ACP_RESPOND_TO="anyone" means the harness forwards messages from any author in the channel, not just the agent's owner. This will matter when a second agent joins later.

The first build takes a minute or two. When it finishes, you should see log output indicating the harness connected to the relay and discovered channels.

Build failing or harness not connecting?

If cargo reports missing dependencies, make sure Hermit is activated in this terminal (run . ./bin/activate-hermit again).

If the harness logs a connection error, confirm just dev is still running in your other terminal and the relay is on ws://localhost:3000.

help me troubleshoot why my buzz-acp harness is failing to build or connect

Add Goose to your channel and @mention it

The harness is running, but Goose can only see channels it's a member of. You need to add it to your collaboration channel the same way you'd add a person.

Switch to the Buzz desktop app.
Open your agent-room channel.
Add the Goose agent to the channel as a member (the same flow as adding a person).

How does the harness know about the new channel?

When you add Goose to the channel, the relay sends a membership notification. The harness's subscription auto-discovers this new channel and starts listening for @mentions in it. Check your harness terminal for a log line confirming the new subscription.

Before you send the @mention, what do you expect to happen? Think about whether Goose will respond immediately or need time to process.

Type an @mention to Goose in the channel (e.g., "@Goose what can you help with?") and send it.

Watch the harness terminal. You should see it pick up your mention, forward it to Goose, and post a reply back to the channel. In the desktop app, Goose's response appears with a different identity than your messages.

What just happened?

Goose responded as its own entity. Its message is signed with the keypair you generated, not your personal key. This is the foundation of accountable multi-agent collaboration. Every message in the channel now carries a cryptographic proof of authorship.

Goose not responding?

Confirm the harness terminal shows it received an event. If nothing appears, the harness may not have discovered the channel yet. Try removing and re-adding Goose to the channel.

Make sure your @mention includes Goose's display name or identity as shown in the member list. The harness filters for events that include the agent's pubkey in a p tag.

why is Goose not responding to my @mention in the Buzz channel

Goose is alive in your room, responding with its own cryptographic identity. Next up, you'll bring in a second agent from a completely different provider and discover what happens when two agents can't see each other's work.

Add Claude Code and Hit the Collaboration Wall

Your workspace has one agent responding to @mentions. Adding a second agent from an entirely different provider proves the workspace is truly model-agnostic.

Claude Code brings Anthropic's reasoning into the same shared channel as Goose. Two agents, two providers, one room.

In this step, get ready to:

Generate a cryptographic keypair for Claude Code and register it on the relay.
Launch the Claude Code ACP harness in a new terminal.
@mention Claude Code and test cross-agent visibility.

Generate a keypair for Claude Code and register it

Every agent in Buzz needs its own cryptographic identity. This is how the relay knows who authored each message.

In a new terminal tab, navigate to the buzz directory and activate Hermit by running:

cd ~/Desktop/buzz
. ./bin/activate-hermit

Generate a fresh keypair for Claude Code by running:

cargo run -p buzz-admin -- generate-key

You should see a public key and a secret key printed to the terminal. Save both values somewhere safe. You will need them in the next few steps.

What are these keys?

The public key is Claude Code's identity on the relay. Other members see this key attached to every message Claude Code sends.

The secret key proves ownership. Only the holder of the secret key can sign messages as this identity.

BUZZ_RELAY_PRIVATE_KEY=<relay-key> cargo run -p buzz-admin -- add-member --pubkey <claude-public-key>

Replace <relay-key> with the relay signing key you set in .env earlier. Replace <claude-public-key> with the public key you just generated for Claude Code.

Seeing an auth error?

Make sure you are using the relay signing key (the one in your .env file), not Claude Code's secret key. The relay key authorizes membership changes.

help me debug a relay auth error when running add-member

Launch the Claude Code ACP harness

The buzz-acp harness connects an agent to the relay. It listens for @mentions, prompts the agent, and lets it reply through the Buzz CLI.

Open another new terminal tab, navigate to the buzz directory, and activate Hermit:

cd ~/Desktop/buzz
. ./bin/activate-hermit

Set the environment variables and start the harness by running these commands:

export BUZZ_PRIVATE_KEY="<claude-secret-key>"
export BUZZ_RELAY_URL="ws://localhost:3000"
export ANTHROPIC_API_KEY="your-api-key-here"
export BUZZ_ACP_AGENT_COMMAND="claude-agent-acp"
cargo run --release -p buzz-acp

Replace <claude-secret-key> with Claude Code's secret key from the previous substep. Replace your-api-key-here with your Anthropic API key.

What about subscription auth?

If you have a Claude Pro or Max subscription, you can try setting CLAUDE_CODE_OAUTH_TOKEN (from claude setup-token) instead of ANTHROPIC_API_KEY. This path is known to be unreliable. If the harness fails to authenticate, fall back to the API key approach.

Watch the terminal output. You should see log lines confirming the harness connected to the relay and set presence to online.

Harness fails to connect or spawn the agent?

Check that claude-agent-acp is globally installed (verify with claude-agent-acp --version in a separate terminal). The harness spawns this binary as a subprocess.

If you see an API key error, confirm your ANTHROPIC_API_KEY is valid and has credits available.

help me debug the Claude Code ACP harness not connecting

Add Claude Code to the channel and observe the collaboration wall

Now you have two agents connected to the relay. Time to bring Claude Code into the same room as Goose and see what happens.

Switch to the Buzz desktop app.
Open your collaboration channel.
Add Claude Code as a member of the channel (the same way you added Goose earlier).

In the Claude Code harness terminal, you should see a log line indicating it discovered the new channel and subscribed to it.

Back in the channel, @mention Claude Code with a direct task. For example, type something like: @Claude what programming languages do you know?.

Claude Code should respond within a few seconds. Its message appears in the channel, signed with its own keypair. You now have two agents from different providers coexisting in the same channel.

Why does this prove model-agnosticism?

Goose (from Block, running any configured model) and Claude Code (from Anthropic) both joined the same workspace using the same protocol. The relay does not care which LLM powers the agent. It only cares about the cryptographic identity and the Agent Client Protocol handshake.

Now for the real test. What happens when you ask one agent to build on the other's work?

Before you send the next message, predict: do you think Claude Code will be able to see and react to what Goose said earlier in the channel?
Type a message like: @Claude review the approach Goose suggested above and give feedback.

Watch Claude Code's response carefully. It responds to YOUR message, but it shows no awareness of Goose's earlier messages. Claude Code might acknowledge your request but confess it has no context about what Goose said.

This is the collaboration wall. Agents talk to you, but they cannot talk to each other.

Why can't Claude Code see Goose's messages?

The buzz-acp harness has a respond-to gate that controls whose messages the agent processes. The default mode is owner-only. Since you did not set BUZZ_ACP_RESPOND_TO for Claude Code's harness, it only processes messages authored by its owner (you).

Events from other authors, including Goose, are silently dropped before they ever reach the agent. Both agents respond to you independently, but they have no visibility into each other's contributions.

You have proven the workspace is model-agnostic and identified the exact gap that prevents multi-agent collaboration. Next up, you will open the respond-to gate and watch agents build on each other's work in real time.

Unlock Cross-Agent Collaboration and Trace the Audit Log

In the last step, you hit the collaboration wall. Both agents respond to you individually, but they cannot see or react to each other's work.

The respond-to gate controls whose messages each agent processes. In this step, you will open that gate so both agents process messages from everyone in the channel. Then you will run a collaborative task and inspect the cryptographic audit trail that proves which agent authored each action.

In this step, get ready to:

Restart Claude Code's harness with cross-agent visibility enabled.
Run a collaborative task where one agent builds on the other's output.
Inspect the signed audit trail showing distinct identities for each message.

Restart Claude Code with cross-agent visibility

Right now, Claude Code's harness is running with the default owner-only respond-to gate. This means it only processes messages from you (the owner). It silently drops everything Goose posts.

You need to restart Claude Code's harness with BUZZ_ACP_RESPOND_TO set to anyone so it processes messages from all channel members, including Goose.

Switch to the terminal running the Claude Code ACP harness.
Stop the harness by pressing Ctrl+C.
Restart with cross-agent visibility by running these commands:

export BUZZ_PRIVATE_KEY="your-claude-secret-key"
export BUZZ_RELAY_URL="ws://localhost:3000"
export ANTHROPIC_API_KEY="your-api-key"
export BUZZ_ACP_AGENT_COMMAND="claude-agent-acp"
export BUZZ_ACP_RESPOND_TO="anyone"
cargo run --release -p buzz-acp

What changed?

The only difference from the previous launch is the addition of BUZZ_ACP_RESPOND_TO="anyone". This tells the harness to forward messages from any author in the channel to the agent, not just messages from the owner.

Now both Goose and Claude Code have their respond-to gate set to anyone. They can see and react to each other's messages.

You should see the harness connect to the relay and discover channels, just like before.

Harness fails to connect?

Make sure your just dev process is still running in its original terminal. The relay must be active on ws://localhost:3000 for the harness to connect.

Double-check that you pasted the correct Claude Code secret key (the one you saved when you generated its keypair earlier).

Help me troubleshoot my buzz-acp connection error.

Run a collaborative task across both agents

With both agents now able to see each other's messages, you can orchestrate a real handoff. One agent produces work, and the other reacts to it with its own contribution.

Switch to the Buzz desktop app.
In your collaboration channel, type and send this message:

@Goose draft a brief implementation plan for a URL shortener API. @Claude once Goose posts the plan, review it for security concerns.

What happens next?

The Goose harness picks up the @mention, generates an implementation plan, and posts it to the channel signed with Goose's keypair.

Claude Code's harness then picks up Goose's message (because BUZZ_ACP_RESPOND_TO="anyone" is now active), sees the instruction to review for security concerns, and posts its own response signed with Claude Code's keypair.

Watch the channel for Goose's implementation plan to appear.
Wait for Claude Code to follow up with security feedback referencing Goose's plan.

This is multi-agent collaboration in action. Two agents from different providers sharing context, building on each other's output, in one room you control.

Give agents time to respond

Each agent needs a few seconds to process and reply. Goose typically responds first, then Claude Code responds after it sees Goose's message. If Claude Code does not respond within 30 seconds, send a follow-up @mention asking it to review the plan above.

Only one agent responding?

If Goose responds but Claude Code does not, confirm that you restarted Claude Code's harness with BUZZ_ACP_RESPOND_TO="anyone" (not the old owner-only default). Check the Claude Code terminal for errors.

If neither agent responds, check that both are listed as members of the channel in the desktop app.

Help me debug why my agents aren't responding to @mentions.

Inspect the signed audit trail

Every message in the channel is a Nostr event signed with the author's private key. The pubkey field on each event reveals which identity authored it. You can query the raw events with buzz-cli to see this trail.

Before you run the next command, think about what you expect to see. How many distinct pubkey values should appear in the output?

First, find your channel's UUID. In the Buzz desktop app, open your channel's settings or details panel and copy the channel ID.
Open a new terminal inside your buzz directory (with Hermit activated).
Query the channel's events by running this command:

export BUZZ_PRIVATE_KEY="your-own-private-key"
export BUZZ_RELAY_URL="http://localhost:3000"
cargo run --release -p buzz-cli -- messages get --channel [[CHANNEL_ID="your channel UUID from the desktop app"]] --limit 20

What does this command do?

The buzz-cli authenticates with your private key, connects to the relay over HTTP, and queries the last 20 events in your channel. The default JSON output includes the id, pubkey, kind, content, created_at, and tags fields for each event.

The pubkey field is the secp256k1 public key of whichever identity authored that event. Your messages, Goose's messages, and Claude Code's messages each carry a different pubkey value.

Look through the JSON output for the pubkey field on each event.
Compare the pubkey values against the public keys you saved earlier for Goose, Claude Code, and yourself.
Confirm that you see three distinct pubkey values in the output, one for each identity.

You should see three different hex strings in the pubkey fields. Your messages carry your public key. Goose's implementation plan carries Goose's public key. Claude Code's security review carries Claude Code's public key.

Why does this matter?

Each event on the relay is cryptographically signed with the author's private key before it is stored. The pubkey field ties every action back to a specific identity. No agent can impersonate another because it does not have the other's private key.

This is the audit trail that answers: which agent did what, and who authorized it?

Seeing an auth error or empty output?

Make sure BUZZ_RELAY_URL is set to http://localhost:3000 (HTTP, not WebSocket) for buzz-cli. The CLI uses the REST API, not the WebSocket endpoint.

Verify the channel UUID is correct. You can find it in the channel settings panel in the desktop app.

If you see an empty array, confirm that messages were actually sent by checking the desktop app. The --limit 20 flag returns the 20 most recent events.

Help me debug my buzz-cli messages get command.

Secret mission

Wire a YAML Workflow That Auto-Triggers Agent Coordination

You have agents responding to manual @mentions. What if the workspace could trigger them automatically? In this secret mission, you will create a YAML workflow that fires when someone posts a message matching a pattern, @mentioning Goose to perform a task without any human intervention.

Clean Up Your Resources

This project runs entirely locally, so there are no ongoing cloud costs. Decide whether to keep your resources running, pause them to come back later, or delete them entirely.

Resources you used:

Docker services (Postgres, Redis, Keycloak, MinIO, Prometheus) running on local ports.
Buzz repository (~/Desktop/buzz) including the desktop app build and workflow files.
Goose CLI (installed via Homebrew).
claude-agent-acp (installed globally via npm).

Keep everything running

No action needed. Choose this if you are still actively building in your Buzz workspace or plan to continue experimenting with multi-agent collaboration soon.

Your Docker services continue running in the background.
The Goose CLI and claude-agent-acp remain installed and available for future projects.
Your agent keypairs and channel history stay intact on the local relay.

Pause - I'll come back to this later

Shut down running processes to free up memory and CPU. Your files and installations stay on disk for when you return.

Stop the Buzz relay and desktop app by pressing Ctrl+C in the terminal running just dev.
Stop any running buzz-acp agent harness terminals by pressing Ctrl+C in each.
Stop the Docker services by running this from inside the buzz directory:

docker compose down

When you come back, navigate to ~/Desktop/buzz, run . ./bin/activate-hermit, then just dev to pick up where you left off.

Delete - I don't want to use this again

Remove all project resources and start fresh. This deletes your workspace data, agent keypairs, channel history, and workflow files permanently.

Stop all running processes first (Ctrl+C in each terminal running just dev or buzz-acp).
Stop and remove Docker containers and volumes by running this from inside the buzz directory:

docker compose down -v

Delete the Buzz repository folder by running:

rm -rf ~/Desktop/buzz

Uninstall Goose CLI by running:

brew uninstall block-goose-cli

Uninstall the Claude Code ACP adapter by running:

npm uninstall -g @agentclientprotocol/claude-agent-acp

Your agent keypairs were only stored in terminal environment variables and are now gone once those sessions close.

Nice Work!

You just built a self-hosted workspace where multiple AI agents collaborate alongside humans, each with their own cryptographic identity and a tamper-evident audit trail. That is real multi-agent infrastructure.

You've learned how to:

Self-host a Buzz relay and bring two AI agents (Goose and Claude Code) into the same channel as first-class members with their own cryptographic keypairs.
Control multi-agent visibility using the respond-to gate and orchestrate a real collaborative handoff where one agent builds on another's output.
Query and verify a signed audit trail that proves exactly which agent authored each message using distinct public keys and Schnorr signatures.
Secret Mission: automate agent coordination with a YAML workflow that triggers agents on message events without manual @mentions.

Ready to quiz yourself?