Block's Buzz selbst hosten: Workspace für Mensch & KI-Agenten

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 betreiben. Der Stack besteht aus vier Diensten in Docker Compose — Relay, PostgreSQL, Redis und MinIO — plus Caddy für HTTPS.

Ähnlicher Leitfaden

Den Hermes Agent privat mit Cloudflare WARP freigeben

Erfahren Sie, wie Sie Ihren Hermes-Agenten mithilfe von Cloudflare WARP und Zero Trust sicher weltweit freigeben und darauf zugreifen können, ohne eingehende Firewall-Ports zu öffnen.

8 MIN LESEZEIT

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.

3. Klicken Sie auf Create Token.
4. Nutzen Sie die Vorlage Edit zone DNS.
5. Konfigurieren Sie die Vorlage wie folgt:
   • Permissions: Zone — DNS — Edit
   • Zone Resources: Include — Specific zone — example.com
6. Klicken Sie auf Continue to summary.
7. Klicken Sie auf Create Token.
8. Kopieren Sie das generierte Token, da es nach dem Schließen der Seite nicht mehr angezeigt wird.
9. Testen Sie das generierte Token in Ihrem Terminal, um sicherzustellen, dass es funktioniert:

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:

# 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

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:

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 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.

    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:

{
  acme_dns cloudflare {env.CLOUDFLARE_API_TOKEN}
}

• Erstellen Sie eine Dockerfile.caddy mit dem folgenden Inhalt, der für compose.caddy.yml erforderlich ist:

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:

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

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

mkdir -p /buzz_backups
crontab -e

Einen nächtlichen Datenbank-Dump-Cronjob hinzufügen:

0 3 * * * cd /home/<user>/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 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:

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:

ln -s kimi-cli /Users/<user>/.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:

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 oder dem buzz-cli. Dieses Paar ist die Identität des buzz-cli im Nostr-Relay.

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:

# Copy the Secret key as the BUZZ_PRIVATE_KEY
echo 'export BUZZ_PRIVATE_KEY="nsec1..."'  >> /home/<user>/.bashrc

echo 'export BUZZ_RELAY_URL="wss://buzz.pafor.me"'  >> /home/<user>/.bashrc

Führen Sie den folgenden Befehl aus, um zu überprüfen, ob das buzz-cli ordnungsgemäß konfiguriert ist:

buzz channels list

Ein Projekt mit dem buzz-cli erstellen

# --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:

cargo install --path crates/git-credential-nostr

Richten Sie git-credential-nostr für die Buzz-Relay-Autorisierung ein:

# 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:

buzz repos create --id koa-email-routing --name "KOA Email Routing" --clone "https://buzz.pafor.me/git/<pub_key>/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:

buzz repos bind --id koa-email-routing --channel <CHANNEL_UUID>

# 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.

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.

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:

  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:

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
• Introducing Buzz
• What is buzz
• How to self-host Buzz (Miget)