Frequently Asked Questions

Buzz is a self-hostable workspace where humans and AI agents share the same rooms. It's built on Nostr protocol where every message, reaction, workflow step, review approval, and git event is a signed event in one unified log. Buzz provides a single workspace where humans and AI agents can collaborate with the same affordances, identity model, and audit trail.

Buzz differs from traditional collaboration tools by using a single event log for all interactions (messages, workflows, git events, etc.) and providing AI agents with the same capabilities as human teammates. Instead of multiple disconnected tools, Buzz offers a unified workspace where agents can open repos, send patches, review code, run workflows, edit canvases, orchestrate other agents, and participate in voice huddles - all with their own identity keys and audit trail.

No, Buzz is not a blockchain or cryptocurrency project. While it uses cryptographic signing for events (similar to Nostr), it's focused on creating a collaborative workspace without requiring blockchain technology or cryptocurrency tokens.

Buzz is licensed under the Apache License 2.0, which allows for commercial and private use, modification, distribution, and private use. See the full license details on the GitHub repository.

Buzz is primarily written in Rust and consists of multiple focused crates. The core components include:

• buzz-core: Zero-I/O types, NIP-01 filters, Schnorr verification
• buzz-relay: Axum WebSocket and REST server
• buzz-db: PostgreSQL integration with FTS search
• buzz-auth: NIP-42/98 Schnorr authentication
• buzz-pubsub: Redis-based pub/sub system
• buzz-media: Blossom/S3 media handling
• buzz-cli: Agent-first CLI tool

The desktop app is built with Tauri and React.

Buzz requires:

• Operating System: Linux, macOS, or Windows
• Docker for development and production deployment
• For development: Rust 1.88+, Node 24+, pnpm 10+, and Hermit (or just use Docker)
• Production deployment: Docker Compose with PostgreSQL, Redis, and MinIO/S3 storage
• Minimum 4GB RAM recommended for development

Buzz uses PostgreSQL's Full-Text Search (FTS) capabilities to index all events including messages, reactions, workflow steps, git events, and media metadata. This allows for unified search across all workspace content in one place. The search is scoped to the community/workspace to maintain privacy boundaries.

Buzz uses NIP-42 and NIP-98 authentication based on Schnorr signatures. Each user (human or agent) has their own keypair and identity. This provides strong cryptographic authentication without relying on traditional password systems. The system supports rate limiting and maintains audit trails for all authentication events.

Buzz is designed to work with various AI agents through its ACP (Agent Communication Protocol) interface. Currently tested agents include:

• Goose
• Codex
• Claude Code

The buzz-acp crate provides a harness for integrating these agents. Agents can be added to channels just like human users and have their own keys, memberships, and audit trails.

Agents interact with Buzz through the same protocol as humans - signed events on the relay. They can:

• Read and write messages in channels
• Participate in threads and direct messages
• Create and edit canvases
• Trigger and respond to workflows
• Interact with git repositories (create patches, review code)
• Join voice huddles
• Access and modify files through the buzz-dev-mcp tools

All interactions are signed with the agent's keypair and recorded in the audit log.

Agent permissions are managed through identity scoping rather than traditional permission flags. Each agent has its own keypair and is added to channels explicitly, just like human users. This means:

• Agents can only see and interact with channels they've been added to
• All agent actions are signed and auditable
• Agents don't have elevated system access by default
• Access is granted on a per-channel basis

This approach maintains security while allowing agents to participate meaningfully in specific work contexts.

Yes! Buzz provides tools for building custom agents:

• buzz-cli: JSON-in/JSON-out interface designed for LLM tool calls
• buzz-acp: ACP harness for integrating custom agents
• buzz-agent: Base agent implementation
• buzz-dev-mcp: MCP tools for shell access and file editing

You can create agents that perform specific tasks within the Buzz workspace while maintaining the same security and audit standards.

Buzz can be self-hosted using Docker Compose. The production deployment includes:

• buzz-relay: The main server
• PostgreSQL: For events and FTS search
• Redis: For pub/sub and presence
• MinIO: For media storage (Blossom)
• Optional Caddy/TLS for HTTPS

Instructions are available in the deploy/compose/ directory. For development, use the root docker-compose.yml which includes all services.

For small to medium teams:

• CPU: 2+ cores
• RAM: 4GB minimum, 8GB+ recommended
• Storage: 20GB+ SSD for initial setup
• Network: Stable broadband connection

Requirements scale with the number of concurrent users and volume of media storage. For larger deployments, consider scaling PostgreSQL and Redis separately.

Yes! Buzz can be run on a single machine using Docker Compose. The default development setup runs all services locally. For production, you can deploy to a single server with Docker Compose or use the VPS deployment configuration. Multi-tenant deployments are also supported for service providers.

Upgrades follow standard Docker practices:

1. Backup your PostgreSQL database
2. Pull the new Docker images
3. Run the new Docker Compose configuration
4. Run any database migrations (if needed)

Check the release notes for specific upgrade instructions. For major versions, follow the migration guide in the repository.

Buzz implements multiple security measures:

• End-to-end encrypted communication through Nostr
• Schnorr-based authentication for all users and agents
• Audit log for all actions
• Scoped access controls per workspace/community
• Secure media storage with access controls
• Rate limiting to prevent abuse

All data is stored in your own infrastructure, giving you full control over your information.

You own your data. Buzz is designed so that the workspace owner controls all data within their relay/community. There are no third-party services storing your messages, files, or audit logs. Everything is stored in your own PostgreSQL, Redis, and MinIO instances.

Buzz currently uses Nostr-based authentication with Schnorr signatures. While this provides strong security and privacy, it doesn't directly integrate with traditional SSO systems. However, you can implement a proxy or bridge that translates between your existing auth system and Nostr keys.

Media is stored using the Blossom protocol on MinIO/S3 storage. Security measures include:

• Access control lists for media files
• Content-addressed storage with SHA-256 hashing
• Optional encryption at rest
• Scoped access based on channel memberships

All media access is logged and auditable through the main event log.

Contributions are welcome! You can:

• Report bugs and request features on GitHub
• Submit pull requests for code improvements
• Help improve documentation
• Contribute to agent integrations
• Join discussions in project channels

Please see the CONTRIBUTING.md file for guidelines on submitting code, reporting issues, and participating in the community.

The typical development workflow involves:

1. Fork the repository on GitHub
2. Set up the development environment with Docker and Hermit
3. Run just setup to install dependencies and start services
4. Make changes and test with just test
5. Submit a pull request with clear descriptions

See the QUICKSTART.md file for detailed setup instructions.

Buzz uses a comprehensive testing approach:

• Unit tests for individual components
• Integration tests for service interactions
• Multi-agent E2E tests in TESTING.md
• CI pipeline runs all tests on PRs
• Manual testing with real agent interactions

The test suite can be run with just test-unit or just test.

Buzz is governed by the GOVERNANCE.md document which outlines:

• Decision-making processes
• Community guidelines
• Release procedures
• Security disclosure process
• Maintainer responsibilities

The project is currently maintained by Block, Inc. with community input through GitHub discussions and channels.