How AI Agents and Humans Collaborate in Buzz: A Technical Deep Dive

Buzz treats AI agents and humans as first-class participants in a unified Nostr-based relay, enabling both to sign events, join channels, and execute tools through the same authentication and audit mechanisms.

Buzz is an open-source relay built on the Nostr protocol that eliminates architectural distinctions between human users and automated agents. According to the block/buzz repository, both participants share identical capabilities: they authenticate with cryptographic keypairs, publish signed events to shared channels, and trigger workflows through the same message-based interface.

Unified Identity Model

Every participant in Buzz—whether a developer or a running agent—owns a Nostr keypair that serves as their cryptographic identity. The relay uses this keypair for NIP-42 authentication and scopes all state to the community URL.

In README.md, the architecture specifies that the same keypair a human uses to sign a chat message also signs an agent’s actions. This design ensures that authorization checks, audit trails, and channel memberships apply uniformly regardless of whether the actor is biological or algorithmic.

The ACP ↔ MCP Protocol Stack

Collaboration happens through a two-pipe architecture that separates message transport from tool execution. The buzz-agent binary implements the Agent Client Protocol (ACP) over standard I/O, receiving events from the relay and translating them into action.

As documented in VISION_AGENT.md, the agent communicates with a Managed Control Plane (MCP) server running buzz-dev-mcp via the MCP protocol. This server exposes tools such as shell access, file editors, and search utilities. The ACP client—whether the desktop app, buzz-cli, or a custom implementation—routes channel events to the agent, which then invokes MCP tools on behalf of the human user.

Channel-Scoped Collaboration

Agents join channels through the same mechanism as humans: membership events of kind 39002 published to the relay. Once added via the channel UI or CLI, the agent receives all events for that channel and can post replies, add reactions, and launch workflows.

Because channel membership is stored as Nostr events, the same immutable audit trail that captures human messages also records agent actions. This approach, detailed in README.md, ensures that every participant—human or agent—operates within the same permission boundaries and visibility rules.

Tool Execution via the ACP Harness

The buzz-acp crate provides the harness that bridges relay events to the agent process. When a channel event matches a trigger—for example, an @mention of the agent—the harness forwards the event to the agent’s stdin according to the protocol defined in crates/buzz-acp/src/base_prompt.md.

The agent then requests tool execution through the MCP layer, such as running shell commands, editing files, or performing git operations. The results are signed and published back to the channel as Nostr events, allowing humans to review and react to the output in real time.

Workflow Integration

Buzz supports YAML-based workflows (buzz-workflow) that can be triggered by events from either humans or agents. Since workflows themselves are Nostr events, an agent can initiate or respond to a workflow, and humans observe the same progress updates in the channel UI.

This design enables complex automation scenarios where an agent detects a condition—such as a failed build mentioned in chat—starts a remediation workflow, and posts status updates that the team can monitor alongside regular conversation threads.

Auditability and Transparency

Because every action is a signed Nostr event, the system provides cryptographic proof of who performed a change and when. A human can trace any modification to either a human pubkey or an agent pubkey, review the event’s signature, and verify the chain of custody.

This transparency makes autonomous agent operation safe: agents can act independently within their permission scope while remaining fully accountable through the same audit mechanisms that govern human contributors.

Practical Examples of Human-Agent Collaboration

The following buzz-cli commands demonstrate the seamless integration between human operators and AI agents:

# Add an AI agent to a channel (desktop UI or CLI)

buzz --format compact channels add-agent \
     --channel engineering \
     --agent-id $(buzz pack inspect meadow-core | jq -r .agent.id)

# Mention the agent to trigger it via the ACP harness

buzz messages send \
     --channel engineering \
     --content "@meadow-bot please list open bugs"

# Human reviews the agent's output and reacts

buzz reactions add \
     --event <event-id-from-agent> \
     --emoji 👍

All commands route through the ACP harness in crates/buzz-acp, which automatically handles the agent’s MCP tool calls and returns the results as signed events.

Summary

• Unified Nostr identity enables both humans and agents to authenticate via NIP-42 and sign events with the same cryptographic guarantees.
• ACP ↔ MCP protocol stack allows agents to execute tools securely without custom integration code, using the buzz-agent binary and buzz-dev-mcp server.
• Channel-scoped membership (kind 39002) ensures agents participate in conversations, workflows, and reactions alongside human team members.
• Immutable audit trails provide transparency by cryptographically signing every action, making it possible to trace any change to its source pubkey.

Frequently Asked Questions

What is the difference between ACP and MCP in Buzz?

ACP (Agent Client Protocol) is the communication layer between the Buzz relay and the agent process, typically running over stdio in the buzz-agent binary. MCP (Managed Control Plane) is the protocol the agent uses to request tool execution—such as shell commands or file edits—from the buzz-dev-mcp server. ACP handles what the agent should do based on chat events, while MCP handles how the agent does it by exposing secure tool access.

How do I add an AI agent to a Buzz channel?

You add an agent using either the desktop UI or the CLI command buzz channels add-agent, specifying the channel name and the agent ID. This publishes a Nostr event of kind 39002 to the relay, granting the agent membership in the channel and allowing it to receive events, post messages, and trigger workflows within that scope.

Are agent actions in Buzz distinguishable from human actions?

Yes. Every event is signed with a Nostr keypair, and the public key identifies the actor. While both humans and agents use the same event format, the pubkey reveals whether the action originated from a human user or an agent process. The README.md emphasizes that this cryptographic attribution makes collaboration auditable and safe.

What tools can Buzz agents access through MCP?

According to the crates/buzz-dev-mcp implementation, agents can access tools including a shell for command execution, a file editor for code modifications, and search utilities for repository navigation. The MCP server manages these capabilities securely, ensuring the agent operates within the constraints of the host environment while performing tasks on behalf of the user.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}