What Is the Nostr Protocol Used for in Buzz? A Technical Deep Dive

Buzz leverages the Nostr protocol as its foundational communication layer, utilizing cryptographically signed events for all user data, authentication, and AI agent interactions across a federated relay network.

The open-source block/buzz repository implements a modern messaging and AI agent platform built entirely around the Nostr protocol. By adopting an event-first architecture, Buzz replaces traditional database-centric designs with decentralized, signed data structures that ensure cryptographic provenance and real-time synchronization across desktop, mobile, and AI components.

Event-First Architecture

Buzz treats the Nostr protocol as its single source of truth, where every piece of state—including profiles, messages, channels, and AI payloads—is represented as a signed Nostr event.

Real-Time Relay Infrastructure

The buzz-relay crate accepts events over WebSocket connections and exposes HTTP endpoints that wrap native Nostr REQ filters. According to the source in crates/buzz-relay/src/api/bridge.rs, the relay provides POST /events, POST /query, and POST /count endpoints, allowing HTTP clients to interact with the event stream without maintaining persistent WebSocket connections. Event processing and side-effects are managed in crates/buzz-relay/src/handlers/side_effects.rs, which handles persistence and real-time fan-out to subscribed clients.

Nostr-First HTTP Surface

As documented in the repository’s AGENTS.md, this HTTP bridge maintains a "Nostr-first HTTP surface" where every request translates to valid Nostr filters. This design ensures that data retrieved via HTTP remains compatible with the broader Nostr ecosystem, providing decentralized consistency while supporting clients that require standard RESTful interfaces.

Nostr Kind Registry and Event Types

All supported event types are enumerated in crates/buzz-core/src/kind.rs, which defines constants for standard NIP specifications and Buzz-specific extensions.

Standard NIP Implementations

The registry includes standard protocol kinds such as profile metadata (kind 0), text notes (kind 1), contact lists (kind 3), and reactions (kind 7). These constants drive validation, storage, and routing decisions throughout the codebase, ensuring that Buzz remains compatible with generic Nostr relays and clients.

Buzz-Specific Extensions

Buzz extends the protocol with custom kinds for AI agents and group management. The kind registry defines KIND_AGENT_PROFILE (10100) for agent metadata and KIND_AGENT_ENGRAM (30174) for encrypted agent memory payloads. Additionally, Buzz implements NIP-29 group specifications using kinds 39000 through 39003 for channel creation, membership management, and moderation events.

NIP-29 Group and Channel Management

Buzz implements the NIP-29 "group" specification to model public channels and private conversations. Events utilize the h tag to carry UUIDs that scope filters to specific channels. The conversion layer in desktop/src-tauri/src/nostr_convert.rs (lines 90-120) transforms these Nostr events into internal structures like ChannelInfo and ChannelMembersResponse, bridging the protocol's decentralized events with the application's UI layer.

Authentication and Identity Verification

NIP-42 Authentication

Buzz employs NIP-42 authentication events (kind 22242) for bearer-token authentication, allowing secure session management without centralized user databases. This mechanism enables the relay to authenticate WebSocket connections using standard Nostr cryptographic proofs.

Identity Binding

The platform implements a one-time identity-binding proof using kind 24243 (KIND_NOSTR_IDENTITY_BINDING). Located in desktop/src/features/profile/lib/nostrIdentityBinding.ts, this mechanism allows users to cryptographically link a Nostr key pair to their Buzz account. The binding event carries an empty content payload—serving as proof of private key control—creating a verifiable ownership chain between the cryptographic identity and the user's profile.

AI Agent Integration via Nostr

AI agents in Buzz are first-class participants in the Nostr protocol. Agents publish metadata using kind 10100 and store encrypted engrams (memory states) using kind 30174. The SDK provides builder patterns in crates/buzz-sdk/src/builders.rs, including the AddMemberBuilder struct (lines 575-592) for constructing NIP-29 compliant membership events. This approach allows agents to be discovered, synchronized, and interacted with through the same relay pipeline that handles user-generated content.

// Build a NIP‑29 “add‑member” event (used by agents and UI)
use buzz_sdk::builders::AddMemberBuilder;
let event = AddMemberBuilder::new(channel_id, member_pubkey)
    .role("member")
    .build(&relay_keys);
relay.submit(event);

Cross-Version Protocol Bridging

To maintain compatibility across components using different library versions, Buzz implements bridge code in desktop/src-tauri/src/relay.rs. This module handles conversions between nostr crate versions 0.36 and 0.37, specifically managing public key parsing via nostr::PublicKey::from_hex and tag serialization with nostr::Tag::parse. This ensures that all system components speak the same Nostr wire format regardless of underlying dependency versions.

// Publish a simple text note from the web client
import { EventBuilder, Keys } from 'nostr-tools';
const keys = Keys.generate();
const builder = EventBuilder.note('Hello Nostr from Buzz!');
await relay.publish(builder.build(), keys);

// Bind a Nostr identity to a user account (mobile)
import 'package:nostr/nosrt.dart';
final keys = Keys.fromSecret(secret);
final binding = NostrEvent(
  kind: 24243,
  tags: [], // empty payload – proof of ownership
  content: '',
);
await relay.publish(binding, keys);

Summary

• Buzz treats the Nostr protocol as its single source of truth for all data, authentication, and agent communication.
• The event-first architecture represents every state change as a signed Nostr event, enabling cryptographic provenance and decentralized synchronization.
• Kind registry in buzz-core/src/kind.rs defines standard NIP types and Buzz-specific extensions (10100, 30174, 39000-39003) for AI agents and group management.
• NIP-29 implementation in nostr_convert.rs handles channel scoping and membership through UUID-tagged events.
• Authentication combines NIP-42 bearer tokens with custom identity-binding proofs (kind 24243) for secure account linking.
• Cross-version compatibility bridges nostr 0.36 and 0.37 to maintain protocol consistency across the desktop and SDK components.

Frequently Asked Questions

What specific Nostr event kinds does Buzz use for AI agents?

Buzz utilizes kind 10100 (KIND_AGENT_PROFILE) for agent metadata and kind 30174 (KIND_AGENT_ENGRAM) for encrypted agent memory payloads. These event kinds allow AI agents to publish discoverable profiles and persist state through the same relay infrastructure that handles user messages, as implemented in crates/buzz-sdk/src/builders.rs.

How does Buzz handle group channels using the Nostr protocol?

Buzz implements the NIP-29 specification for group management, using event kinds 39000-39003 for channel operations. Events carry an h tag containing a UUID that scopes the event to a specific channel. The conversion logic in desktop/src-tauri/src/nostr_convert.rs transforms these events into internal application structures while maintaining Nostr protocol compatibility.

What authentication mechanisms does Buzz implement via Nostr?

Buzz employs NIP-42 authentication events (kind 22242) for bearer-token session management. Additionally, Buzz defines a custom kind 24243 (KIND_NOSTR_IDENTITY_BINDING) that allows users to prove ownership of a Nostr key pair by publishing a signed event with empty content, linking the cryptographic identity to their Buzz account through nostrIdentityBinding.ts.

How does Buzz integrate HTTP clients with the Nostr protocol?

The buzz-relay crate exposes HTTP endpoints (POST /events, POST /query, POST /count) that wrap native Nostr REQ and REQ-COUNT filters. This bridge, implemented in crates/buzz-relay/src/api/bridge.rs, allows HTTP clients to publish and query Nostr events without maintaining WebSocket connections, while preserving the protocol's event structure and cryptographic signatures.

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