---
title: "Block's Buzz selbst hosten: Workspace für Mensch & KI-Agenten"
description: "Lernen Sie, wie Sie das Nostr-Relay Block's Buzz auf einem Ubuntu VPS hinter Cloudflare selbst hosten. Ein sicherer Workspace für Menschen und KI-Agenten."
canonical_url: "https://techvoyage.dev/de/article/self-hosting-buzz-as-the-workspace-where-ai-agents-become-colleagues"
last_updated: "2026-10-20T09:53:49.814Z"
---
Die Fragmentierung des Kontexts ist eine frustrierende Hürde bei der Arbeit mit mehreren KI-Agenten. Wenn Konversationen über verschiedene Tools verstreut sind, agieren Sie letztendlich als menschlicher Router, indem Sie Gespräche aus Claude Code kopieren, um sie in die Gemini-CLI einzufügen, und dann aus der Gemini-CLI kopieren, um sie in den Hermes-Agenten einzufügen. Diese Reibung nimmt zu, wenn auch noch menschliche Kollegen im selben Team sind.
**Buzz**, ein Open-Source-Kollaborations-Workspace, bringt menschliche Teams und KI-Agenten in einer einzigen, einheitlichen Umgebung zusammen. Hier teilen sich menschliche Kollegen und KI-Agenten dieselbe Aufgaben- und Projekthistorie und übergeben sich nahtlos gegenseitig die Arbeit.
## Was ist Block's Buzz? Der kollaborative Workspace für KI-Agenten
Buzz ist ein Open-Source-Kollaborations-Workspace von Block (dem Unternehmen von Jack Dorsey), in dem Menschen und KI-Agenten dieselben Kanäle und Projekte teilen. Es bietet die folgenden Hauptfunktionen:
- **Gemeinsamer Kontext:** In den Kanälen arbeiten Menschen und Agenten zusammen. Der gesamte Konversations- und Projektverlauf ist im Kanal enthalten.
- **Agent-zu-Agent-Kommunikation:** Agenten können miteinander kommunizieren, selbst über verschiedene Maschinen hinweg. Ein Agent kann einen anderen Agenten per @-Mention erwähnen, um Arbeit zu übergeben oder Code abzugleichen.
- **Erwähnungsveranlasste Aktivierung (Mention-driven):** Agenten agieren nur, wenn sie per @-Mention erwähnt werden, ansonsten verhalten sie sich ruhig. Bei einer Erwähnung liest ein Agent den relevanten Kontext im Kanal und beginnt mit der Arbeit.
- **Einheitliches Identitätssystem:** Menschen und Agenten nutzen dasselbe Identitätssystem, das über kryptografische Schlüssel authentifiziert wird.
- **Delegierte Befehle:** Sie können menschlichen Kollegen die Berechtigung erteilen, Ihre Agenten zu steuern, sodass das gesamte Team die digitalen Helfer der anderen instruieren und nutzen kann.
- **Selbst gehostete Server (Self-hosted):** Da Sie den Server selbst hosten, bleiben Ihre Daten vollständig unter Ihrer Kontrolle. Sie entscheiden, wer beitritt, und definieren Ihre eigenen Betriebsregeln.
## Die kryptografische, Nostr-basierte Architektur von Buzz
- **Das Nostr-Relay fungiert als Server:** Nachrichten, Workflows, Repositories und andere Events werden kryptografisch signiert, verifiziert und auf einem Nostr-Relay-Server gespeichert. Das Nostr-Protokoll unterstützt nativ die Kommunikation über WebSockets und REST-APIs.
- **Einheitliche kryptografische Identität:** Sowohl Menschen als auch Agenten authentifizieren sich mit ihren eigenen kryptografischen Schlüsseln. Diese Identität bleibt auf der Client-Seite und wird niemals auf dem Server gespeichert.
- **Erstklassige Agenten-Mitgliedschaft:** Jeder Agent besitzt seine eigene Identität, Kanalmitgliedschaften und ein Audit-Protokoll. Agenten verbinden sich über das Agent Communication Protocol (ACP) mit dem Workspace.
- **Dezentrale Git-Repositories:** Code-Repositories werden auf S3-kompatiblem Objektspeicher gesichert, während Aufgaben, Pull Requests und Code-Reviews im Nostr-Event-Log nachverfolgt werden. Folglich wird ein Buzz-Git-Repository auf dem Nostr-Relay und nicht auf GitHub gehostet.
- **Die Buzz-App is ein Nostr-Client:** Buzz ist unabhängig vom Nostr-Relay; es ist eine Desktop-/Mobile-Client-Anwendung, die sich mit der URL des Relays verbindet.
- **Infrastruktur-Stack:** Eine PostgreSQL-Datenbank übernimmt die Event-Speicherung und Volltextsuche, Redis verwaltet das Pub/Sub-Messaging und MinIO (S3-kompatibel) wird für die Medienspeicherung verwendet.
## Block's Buzz Relay auf einem Linux-VPS selbst hosten: Eine Anleitung
### 0. Voraussetzungen
- Ein Linux-VPS
- Eine Domain, die auf Ihren Server zeigt
- Docker und das Docker Compose-Plugin
- Cloudflare-Konto (kostenlose Version)
In diesem Guide werden wir das Nostr-Relay auf einem Ubuntu-VPS hinter einem privaten Netzwerk von [Den Hermes Agent privat mit Cloudflare WARP freigeben](/article/exposing-hermes-agent-to-private-network-using-cloudflare-warp) betreiben. Der Stack besteht aus vier Diensten in Docker Compose — Relay, PostgreSQL, Redis und MinIO — plus Caddy für HTTPS.
### 1. Cloudflare-DNS und API-Token
#### Cloudflare-API-Token erstellen
1. Klicken Sie auf das Profilsymbol oben rechts und wählen Sie das Menü **Profile** aus.
2. Klicken Sie auf **API Tokens**.
1. Klicken Sie auf **Create Token**.
2. Nutzen Sie die Vorlage **Edit zone DNS**.
3. Konfigurieren Sie die Vorlage wie folgt:
- **Permissions**: Zone — DNS — Edit
- **Zone Resources**: Include — Specific zone — `example.com`
4. Klicken Sie auf **Continue to summary**.
5. Klicken Sie auf **Create Token**.
6. Kopieren Sie das generierte Token, da es nach dem Schließen der Seite nicht mehr angezeigt wird.
7. Testen Sie das generierte Token in Ihrem Terminal, um sicherzustellen, dass es funktioniert:
```bash
curl "https://api.cloudflare.com/client/v4/user/tokens/verify" -H "Authorization: Bearer YOUR_TOKEN_HERE"
```
#### DNS-Einträge
- Erstellen Sie einen A-Eintrag und setzen Sie ihn auf **DNS only**.
### 2. Docker auf Ubuntu installieren
Führen Sie die folgenden Befehle aus, um Docker auf Ubuntu zu installieren:
```bash
# Add Docker's official GPG key and set up the Docker repository
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
# Add the official Docker repository
echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
# Update package list
sudo apt update
# Install Docker Engine, Docker Community Edition, and containerd runtime
sudo apt install docker-ce docker-ce-cli containerd.io -y
# Start automatically when the system boots
sudo systemctl enable docker
# Verify docker is installed
docker --version
sudo apt install -y docker-compose-plugin
# Verify the compose plugin is installed
docker compose version
```
### 3. Klonen und konfigurieren
```bash
git clone https://github.com/block/buzz.git
cd buzz/deploy/compose
cp .env.example .env
nano .env
```
Editieren Sie die `.env` in Gruppen:
- **Domain:**
```text
BUZZ_DOMAIN=buzz.pafor.me
RELAY_URL=wss://buzz.pafor.me
BUZZ_PAIRING_RELAY_URL=wss://buzz.pafor.me/pair
BUZZ_MEDIA_BASE_URL=https://buzz.pafor.me/media
BUZZ_MEDIA_SERVER_DOMAIN=buzz.pafor.me
BUZZ_CORS_ORIGINS=https://buzz.pafor.me
```
- **Besitzerschlüssel:** `RELAY_OWNER_PUBKEY` erfordert Ihren 64-stelligen hexadezimalen öffentlichen Schlüssel. Erstellen Sie zuerst eine Identität in der Desktop-App ('Create a new identity key' → kopieren Sie Ihre öffentliche ID, die im npub-Format vorliegt) und konvertieren Sie diese dann in Hex.
- **Geheimnisse (Secrets):**
- Generieren Sie Geheimnisse mit diesem [Online-Tool](/de/tools/secret-key-hex) oder mit `openssl rand -hex 32` (führen Sie es siebenmal aus)
- Ersetzen Sie jeden `CHANGE_ME`-Platzhalter: `BUZZ_RELAY_PRIVATE_KEY`, `BUZZ_GIT_HOOK_HMAC_SECRET`, die Passwörter für Postgres/Redis/Typesense und die S3-Zugangs-/Geheimschlüssel.
- Verbleibende Platzhalter sind die häufigste Ursache für Container-Neustartschleifen; überprüfen Sie Ihre mit `grep CHANGE_ME .env`.
```text
BUZZ_RELAY_PRIVATE_KEY=CHANGE_ME_64_HEX_PRIVATE_KEY
BUZZ_GIT_HOOK_HMAC_SECRET=CHANGE_ME_RANDOM_64_HEX
POSTGRES_PASSWORD=CHANGE_ME_RANDOM_PASSWORD
REDIS_PASSWORD=CHANGE_ME_RANDOM_PASSWORD
TYPESENSE_API_KEY=CHANGE_ME_RANDOM_API_KEY
BUZZ_S3_ACCESS_KEY=CHANGE_ME_RANDOM_ACCESS_KEY
BUZZ_S3_SECRET_KEY=CHANGE_ME_RANDOM_SECRET_KEY
```
- **Sonstiges:**
- Fügen Sie `CLOUDFLARE_API_TOKEN` als Umgebungsvariable hinzu und weisen Sie das zuvor generierte API-Token zu. Dies wird für Caddy benötigt.
- Buzz wird mit offenen Standardeinstellungen ausgeliefert — jeder, der Ihre Relay-URL kennt, kann sich authentifizieren und beitreten. Setzen Sie `RELAY_OWNER_PUBKEY`, `BUZZ_REQUIRE_RELAY_MEMBERSHIP=true` und `BUZZ_REQUIRE_AUTH_TOKEN=true`.
### 4. HTTPS mit Caddy aktivieren
#### Eigenes Caddy-Image mit dem Cloudflare-DNS-Modul erstellen
- Wir richten DNS-01 mit Cloudflare für Caddy ein. DNS-01 funktioniert, indem das Plugin einen TXT-Eintrag `_acme-challenge.buzz.pafor.me` in das **öffentliche DNS** schreibt;
- Let's Encrypt ruft den Eintrag dann aus dem öffentlichen Internet ab, um die Domaininhaberschaft zu überprüfen. Das bedeutet, dass `pafor.me` eine öffentliche Zone in Ihrem Cloudflare-Konto sein muss — nicht nur ein privater Hostname, der nur im privaten DNS von Zero Trust / WARP existiert. Wenn `buzz.pafor.me` nur privat aufgelöst wird und keine öffentliche Zone vorhanden ist, schlägt DNS-01 fehl, was einen anderen Ansatz erfordert.
- Fügen Sie Folgendes zum Caddyfile hinzu:
```yml
{
acme_dns cloudflare {env.CLOUDFLARE_API_TOKEN}
}
```
- Erstellen Sie eine Dockerfile.caddy mit dem folgenden Inhalt, der für compose.caddy.yml erforderlich ist:
```yml
FROM caddy:2-builder AS builder
RUN xcaddy build \
--with github.com/caddy-dns/cloudflare
FROM caddy:2-alpine
COPY --from=builder /usr/bin/caddy /usr/bin/caddy
```
- Ändern Sie `compose.caddy.yml`, um das Image mit dem Cloudflare-Modul zu verwenden und das Cloudflare-API-Token zu übergeben:
```yml
services:
relay:
ports: !reset []
caddy:
build:
context: .
dockerfile: Dockerfile.caddy
image: buzz-caddy:cloudflare
depends_on:
relay:
condition: service_healthy
environment:
BUZZ_DOMAIN: ${BUZZ_DOMAIN:?set BUZZ_DOMAIN}
CLOUDFLARE_API_TOKEN: ${CLOUDFLARE_API_TOKEN:?set CLOUDFLARE_API_TOKEN}
ports:
- "${CADDY_HTTP_PORT:-80}:80"
- "${CADDY_HTTPS_PORT:-443}:443"
volumes:
- ./Caddyfile:/etc/caddy/Caddyfile:ro
- buzz-caddy-data:/data
- buzz-caddy-config:/config
restart: unless-stopped
networks:
- buzz-net
volumes:
buzz-caddy-data:
labels:
com.buzz.volume: caddy-data
buzz-caddy-config:
labels:
com.buzz.volume: caddy-config
```
#### Docker-Container starten
```bash
docker compose -f compose.yml -f compose.caddy.yml up -d
#Check the Docker status
docker compose ps
```
Öffnen Sie Ihren Webbrowser und navigieren Sie zu `http://buzz.pafor.me`, um zu überprüfen, ob das Relay läuft.
### Schritt 5: Backup von Tag eins an einrichten
```bash
mkdir -p /buzz_backups
crontab -e
```
Einen nächtlichen Datenbank-Dump-Cronjob hinzufügen:
```text
0 3 * * * cd /home//buzz/deploy/compose && docker compose exec -T postgres pg_dump -U buzz buzz > /buzz_backups/buzz-$(date +\%Y\%m\%d).sql
```
Hinweis: Behandeln Sie BUZZ_RELAY_PRIVATE_KEY als permanent. Events, die damit signiert wurden, schlagen bei der Verifizierung fehl, wenn sich der Schlüssel ändert; eine wiederhergestellte Datenbank gepaart mit einem neuen Schlüssel wird nicht als dasselbe Relay behandelt.
## Einrichtung des Buzz-Desktop-Clients und der Nostr-Identitäten
Laden Sie die Buzz-Desktop-App von [https://github.com/block/buzz/releases](https://github.com/block/buzz/releases) herunter und starten Sie sie. Füllen Sie die Profildetails aus, bis Sie die Seite "Join or create a community" erreichen.
Klicken Sie auf "Join a community" und kopieren Sie Ihren öffentlichen Schlüssel.
Führen Sie den folgenden Befehl auf dem **VPS** aus, um sich selbst als erstes Mitglied hinzuzufügen:
```bash
docker compose exec relay buzz-admin add-member --pubkey npub1yourkeyhere
```
Fügen Sie `wss://buzz.pafor.me` als Community-URL hinzu und klicken Sie auf "Next".
Geben Sie einen Namen ein und klicken Sie auf die Schaltfläche Next.
### Kanäle (Channels) und Agenten
Kanäle sind Aufgabengruppen oder Projektgruppen. Erstellen Sie einen Kanal pro Aufgabe oder Projekt und laden Sie Menschen und Agenten hinein.
Alles innerhalb eines Kanals wird automatisch geteilt, sodass kein Mitglied einzeln instruiert werden muss. Jeder Agent kann über @ erwähnt werden und liest die relevanten Nachrichten. Zudem können Agenten sich gegenseitig per @ erwähnen.
Senden wir eine DM an einen vorkonfigurierten Agenten
Erstellen wir einen Kanal und fügen einige Agenten hinzu
### Agenten-Runtimes aktivieren
Vordefinierte Runtimes verlassen sich auf die automatische Erkennung, die Start-Binärdateien (z. B. `hermes-acp`) in Standardverzeichnissen wie `~/.local/bin` sucht. Wenn ein Tool an einem nicht standardmäßigen Speicherort installiert wurde, kann Buzz es nicht auflösen.
Für Kimi Code lautet die Agenten-ID kimi, und Buzz sucht nach der Binärdatei unter `~/.local/bin/kimi`. Ein symbolischer Link erledigt die Arbeit:
```text
ln -s kimi-cli /Users//.local/bin/kimi
```
Kimi Code erscheint nun unter den Agenten-Runtimes.
### Projekte und Repositories
Aktivieren Sie zuerst die Funktion '**Projects**' unter Settings → Experiments:
Derzeit muss ein Projekt mit dem `buzz-cli` erstellt werden (obwohl die direkte Projekterstellung über die Benutzeroberfläche für ein zukünftiges Release geplant ist).
#### Installieren des buzz-cli
Führen Sie die folgenden Befehle aus, um `buzz-cli` auf dem **VPS** zu installieren:
```bash
sudo apt install cargo
cd ~/buzz
cargo install --path crates/buzz-cli
echo 'export PATH="$HOME/.cargo/bin:$PATH"' >> ~/.bashrc && source ~/.bashrc
```
Generieren Sie ein Paar aus privatem und öffentlichem Schlüssel mit dem [Online-Tool](/de/tools/nostr-key-generator) oder dem `buzz-cli`. Dieses Paar ist die Identität des `buzz-cli` im Nostr-Relay.
```bash
docker run --rm --entrypoint /usr/local/bin/buzz-admin ghcr.io/block/buzz:main generate-key
# Use the generated Public Key
docker compose exec relay buzz-admin add-member --pubkey generated_Public_key
```
Konfigurieren Sie die CLI:
```bash
# Copy the Secret key as the BUZZ_PRIVATE_KEY
echo 'export BUZZ_PRIVATE_KEY="nsec1..."' >> /home//.bashrc
echo 'export BUZZ_RELAY_URL="wss://buzz.pafor.me"' >> /home//.bashrc
```
Führen Sie den folgenden Befehl aus, um zu überprüfen, ob das `buzz-cli` ordnungsgemäß konfiguriert ist:
```bash
buzz channels list
```
#### Ein Projekt mit dem buzz-cli erstellen
```bash
# --channel refers to the UUID of the channel
buzz repos create --id TestKOA --name 'Display Name' --channel "bd92b3d1-8fac-441c-a9ac-2b2f3aac5c5b"
```
Ein Projekt kann nur von seinem Besitzer entfernt werden. Da das Projekt "Display Name" über das `buzz-cli` erstellt wurde, welches keinen Löschbefehl besitzt, kann es auf diese Weise nicht gelöscht werden.
Prüfen Sie in der Buzz-Desktop-App nach, ob das Projekt erstellt wurde.
Sobald ein Projekt in Projects verfügbar ist, können weitere Projekte über die Schaltfläche "+" in der oberen rechten Ecke hinzugefügt werden.
#### Bestehende Git-Repositories einbinden
Installieren Sie `git-credential-nostr` auf dem Rechner, auf dem sich die Git-Repositories befinden. Es erfordert **Git 2.46+** und die Rust-Toolchain. Beziehen Sie sich auf diese [Readme](https://github.com/block/buzz/tree/main/crates/git-credential-nostr):
```bash
cargo install --path crates/git-credential-nostr
```
Richten Sie `git-credential-nostr` für die Buzz-Relay-Autorisierung ein:
```bash
# 1. Register the helper and enable per-path credentials.
git config --global credential.helper nostr
git config --global credential.useHttpPath true
# 2. Store your nsec in a key file (must be 0600). Replace "nsec1..." with your private key
mkdir -p ~/.nostr
echo "nsec1..." > ~/.nostr/key && chmod 600 ~/.nostr/key
git config --global nostr.keyfile ~/.nostr/key
```
Erstellen Sie ein Repository auf dem Buzz-Relay:
```text
buzz repos create --id koa-email-routing --name "KOA Email Routing" --clone "https://buzz.pafor.me/git//koa-email-routing" --nostr-relay "wss://buzz.pafor.me"
```
Bei Ihrem ersten `git push` stoßen Sie auf den Fehler `remote: missing Authorization header`. Um dies zu beheben, müssen Sie die Repository-ID an einen Buzz-Kanal binden, da die Kanalmitgliedschaft die Git-Schreibrechte (ACLs) vorgibt:
```bash
buzz repos bind --id koa-email-routing --channel
# push the code again
git push
```
Die Überprüfung des Projekts in der Buzz-Desktop-App zeigt Folgendes, da die App **Git 2.46+** benötigt — das direkte Starten der App verwendet möglicherweise eine ältere Git-Version:
Exportieren Sie den PATH über `launchctl setenv PATH "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin"` im Shell-Profil und starten Sie die Buzz-App aus der Shell heraus. Beziehen Sie sich auf dieses [Issue](https://github.com/block/buzz/issues/5348).
```bash
open -a Buzz
```
Überprüfen Sie die Projects in der Buzz-App; die Repository-Details sind jetzt geladen.
## KI-Agenten per QR-Code mit der Buzz Mobile App synchronisieren
Die Kopplung der Buzz Mobile App akzeptiert nur das HTTPS-Protokoll und das `buzz-pair-relay` wird auf dem VPS standardmäßig nicht gestartet.
```bash
cd ~/buzz
cargo install --path crates/buzz-pair-relay
```
Fügen Sie Folgendes zu `compose.yml` hinzu, um den `buzz-pair-relay`-Dienst zu starten:
```yml
pair:
image: ${BUZZ_IMAGE:-ghcr.io/block/buzz:main}
entrypoint: ["/usr/local/bin/buzz-pair-relay"]
environment:
BUZZ_PAIR_RELAY_BIND_ADDR: 0.0.0.0:5000
ports:
- "${BUZZ_PAIR_RELAY_PORT:-5000}:5000"
restart: unless-stopped
networks:
[buzz-net]
```
Fügen Sie `BUZZ_PAIRING_RELAY_URL` und `BUZZ_PAIR_RELAY_PORT` zur Datei `.env` hinzu:
```text
BUZZ_PAIRING_RELAY_URL=wss://buzz.pafor.me/pair
BUZZ_PAIR_RELAY_PORT=5000
```
Gehen Sie in den Desktop-Einstellungen von Buzz zu '**Mobile**':
Klicken Sie auf "Start pairing" — ein QR-Code wird generiert. Scannen Sie diesen QR-Code mit der Buzz-App auf dem Mobilgerät. Die Geräte werden gekoppelt, nachdem Sie auf "Code Match" geklickt haben.
Die Agenten in der Buzz Mobile App sind verfügbar, wenn sie in der Buzz-Desktop-App ausgeführt werden. Der Desktop-Rechner muss laufen, damit die Agenten funktionieren.
## Fazit
Obwohl Buzz für große Produktionsumgebungen aufgrund einiger Bugs und Einschränkungen in der Benutzeroberfläche noch zu früh ist, stellt es eine aufregende Erfahrung für kleine Teams und Solo-Entwickler dar. Es bietet einen Vorgeschmack darauf, wie sich ein kollaborativer, KI-zentrierter Workspace wirklich anfühlt.
## Referenzen
- [Buzz releases](https://github.com/block/buzz)
- [Introducing Buzz](https://block.xyz/inside/introducing-buzz-where-humans-and-agents-work-together)
- [What is buzz](https://www.hostinger.com/tutorials/what-is-buzz)
- [How to self-host Buzz (Miget)](https://miget.com/blog/how-to-self-host-buzz)