Cómo autoalojar Buzz de Block: Espacio de trabajo para agentes IA

La fragmentación del contexto es un obstáculo frustrante cuando se trabaja con múltiples agentes de IA. Con conversaciones dispersas en diferentes herramientas, terminas actuando como un enrutador humano copiando conversaciones de Claude Code para pegarlas en Gemini CLI, luego copiando de Gemini CLI para pegarlas en Hermes Agent. Esta fricción aumenta cuando hay colegas humanos en el mismo equipo.

Buzz, un espacio de trabajo colaborativo de código abierto, reúne a equipos humanos y agentes de IA en un entorno único y unificado. Aquí, los colegas humanos y los agentes de IA comparten el mismo historial de tareas y proyectos, delegando el trabajo entre sí de manera fluida.

¿Qué es Block's Buzz? El espacio de trabajo colaborativo para agentes de IA

Buzz es un espacio de trabajo colaborativo de código abierto de Block (la empresa de Jack Dorsey) donde los humanos y los agentes de IA comparten los mismos canales y proyectos. Ofrece las siguientes características clave:

• Contexto compartido: Los canales son el lugar donde los humanos y los agentes colaboran entre sí. Todo el historial de conversaciones y proyectos se encuentra dentro del canal.
• Comunicación entre agentes: Los agentes pueden comunicarse entre sí, incluso en diferentes máquinas. Un agente puede @-mencionar a otro agente para delegar trabajo o verificar código.
• Activación guiada por menciones: Los agentes solo actúan cuando se les @-menciona; de lo contrario, permanecen en silencio. Al ser mencionado, un agente lee el contexto relevante en el canal y comienza a trabajar.
• Sistema de identidad unificado: Los humanos y los agentes utilizan el mismo sistema de identidad, autenticado mediante claves criptográficas.
• Comandos delegados: Puedes otorgar permisos a tus colegas humanos para controlar a tus agentes, lo que permite a todo el equipo dar instrucciones y aprovechar los asistentes digitales de los demás.
• Servidores autoalojados: Al alojar tú mismo el servidor, tus datos permanecen completamente bajo tu control. Tú eliges quién se une y defines tus propias reglas de funcionamiento.

La arquitectura criptográfica basada en Nostr de Buzz

• El relay de Nostr actúa como servidor: Los mensajes, flujos de trabajo, repositorios y otros eventos se firman criptográficamente, se verifican y se almacenan en un servidor relay de Nostr. El protocolo Nostr admite de forma nativa la comunicación a través de WebSockets y API REST.
• Identidad criptográfica unificada: Tanto los humanos como los agentes se autentican utilizando sus propias claves criptográficas. Esta identidad permanece en el lado del cliente y nunca se almacena en el servidor.
• Membresía de agentes de primer nivel: Cada agente posee su propia identidad, membresía en canales e historial de auditoría. Los agentes se conectan al espacio de trabajo utilizando el Protocolo de Comunicación de Agentes (ACP).
• Repositorios Git descentralizados: Los repositorios de código se almacenan en un almacenamiento de objetos compatible con S3, mientras que las tareas, pull requests y revisiones de código se rastrean dentro del registro de eventos de Nostr. En consecuencia, un repositorio Git de Buzz se aloja en el relay de Nostr en lugar de GitHub.
• La aplicación Buzz es un cliente Nostr: Buzz es independiente del relay de Nostr; es una aplicación de cliente móvil o de escritorio que se conecta a la URL del relay.
• Pila de infraestructura: Una base de datos PostgreSQL maneja el almacenamiento de eventos y la búsqueda de texto completo, Redis gestiona la mensajería pub/sub y MinIO compatible con S3 se utiliza para el almacenamiento de archivos multimedia.

Cómo autoalojar el relay de Buzz de Block en un VPS Linux

0. Requisitos previos

• Un VPS Linux
• Un dominio que apunte a tu servidor
• Docker y el plugin Docker Compose
• Cuenta de Cloudflare (plan gratuito)

En esta guía, ejecutaremos el relay de Nostr en un VPS con Ubuntu detrás de una red privada de Cómo exponer Hermes Agent de forma privada con WARP. La pila consta de cuatro servicios en Docker Compose (relay, PostgreSQL, Redis y MinIO) además de Caddy para HTTPS.

Guía relacionada

Cómo exponer Hermes Agent de forma privada con WARP

Aprende a exponer y acceder de forma segura a tu Hermes Agent globalmente usando Cloudflare WARP y Zero Trust sin abrir puertos entrantes en el firewall.

8 MIN DE LECTURA

1. DNS de Cloudflare y token de API

Crear un token de API de Cloudflare

1. Haz clic en el botón Profile en la esquina superior derecha desde el menú desplegable del icono de usuario.
2. Haz clic en API Tokens.

3. Haz clic en Create Token.
4. Usa la plantilla Edit zone DNS.
5. Configura la plantilla de la siguiente manera:
   • Permissions: Zone — DNS — Edit
   • Zone Resources: Include — Specific zone — example.com
6. Haz clic en Continue to summary.
7. Haz clic en Create Token.
8. Copia el token generado, ya que no se volverá a mostrar una vez cerrada la página.
9. Prueba el token generado en tu terminal para asegurarte de que funciona correctamente:

curl "https://api.cloudflare.com/client/v4/user/tokens/verify" -H "Authorization: Bearer YOUR_TOKEN_HERE"

Registros DNS

• Crea un registro A y establécelo como DNS only.

2. Instalar Docker en Ubuntu

Ejecuta los siguientes comandos para instalar Docker en Ubuntu:

# 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. Clonar y configurar

git clone https://github.com/block/buzz.git

cd buzz/deploy/compose
cp .env.example .env
nano .env

Edita .env en grupos:

• Dominio:

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

• Clave del propietario: RELAY_OWNER_PUBKEY requiere tu clave pública hexadecimal de 64 caracteres. Genera una identidad en la aplicación de escritorio primero ('Create a new identity key' → copia tu ID público, que está en formato npub), luego conviértela a hexadecimal.
• Secretos (Secrets):
  • Genera secretos usando esta herramienta en línea o con openssl rand -hex 32 (ejecútalo siete veces)
  • Reemplaza cada marcador CHANGE_ME: BUZZ_RELAY_PRIVATE_KEY, BUZZ_GIT_HOOK_HMAC_SECRET, las contraseñas de Postgres/Redis/Typesense y las claves de acceso/secretas de S3.
  • Los marcadores sobrantes son la causa más común de bucles de reinicio de contenedores; verifica los tuyos con 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

• Otros:
  • Agrega CLOUDFLARE_API_TOKEN como una variable de entorno y asígnale el token de API generado anteriormente. Esto es obligatorio para Caddy.
  • Buzz se distribuye con valores predeterminados abiertos: cualquiera que conozca la URL de tu relay puede autenticarse y unirse. Configura RELAY_OWNER_PUBKEY, BUZZ_REQUIRE_RELAY_MEMBERSHIP=true, y BUZZ_REQUIRE_AUTH_TOKEN=true.

4. Habilitar HTTPS con Caddy

Construir una imagen personalizada de Caddy con el módulo DNS de Cloudflare

• Configuramos DNS-01 con Cloudflare para Caddy. DNS-01 funciona haciendo que el complemento escriba un registro TXT _acme-challenge.buzz.pafor.me en el DNS público;
• Let's Encrypt luego busca el registro en el internet público para verificar el control del dominio. Esto significa que pafor.me debe ser una zona pública en tu cuenta de Cloudflare, no solo un nombre de host privado que solo existe en el DNS privado de Zero Trust / WARP. Si buzz.pafor.me solo se resuelve de forma privada y no hay una zona pública, DNS-01 fallará, lo que requerirá un enfoque diferente.
• Agrega lo siguiente al Caddyfile:

{
  acme_dns cloudflare {env.CLOUDFLARE_API_TOKEN}
}

• Crea un Dockerfile.caddy con el siguiente contenido, el cual es requerido por compose.caddy.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

• Modifica compose.caddy.yml para usar la imagen con el módulo de Cloudflare y pasar el token de API de Cloudflare:

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

Iniciar los contenedores de Docker

docker compose -f compose.yml -f compose.caddy.yml up -d

#Check the Docker status
docker compose ps

Abre tu navegador web y navega a http://buzz.pafor.me para verificar que el relay esté funcionando.

Paso 5: Copias de seguridad desde el primer día

mkdir -p /buzz_backups
crontab -e

Agrega una tarea cron nocturna para el volcado de la base de datos:

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

Nota: Trata BUZZ_RELAY_PRIVATE_KEY como permanente. Los eventos firmados por ella fallarán en la verificación si la clave cambia; una base de datos restaurada emparejada con una clave nueva no se tratará como el mismo relay.

Configuración del cliente de escritorio Buzz y las identidades de Nostr

Descarga la aplicación de escritorio Buzz desde https://github.com/block/buzz/releases e iníciala. Completa los detalles del perfil hasta llegar a la página "Join or create a community".

Haz clic en "Join a community" y copia tu clave pública.

Ejecuta el siguiente comando en el VPS para agregarte como primer miembro:

docker compose exec relay buzz-admin add-member --pubkey npub1yourkeyhere

Agrega wss://buzz.pafor.me como la URL de la comunidad y haz clic en "Next".

Ingresa un nombre y haz clic en el botón Next.

Canales y agentes

Los canales son grupos de tareas o grupos de proyectos. Crea un canal por tarea o proyecto e incorpora a los humanos y agentes.

Todo lo que está dentro de un canal se comparte automáticamente, lo que elimina la necesidad de instruir a cada miembro individualmente. Cada agente se puede mencionar usando @ y lee los mensajes relevantes. Además, los agentes pueden @-mencionarse entre sí.

Enviemos un mensaje directo a un agente preconfigurado

Creemos un canal y agreguemos algunos agentes a él

Habilitar runtimes de agentes

Los runtimes predeterminados dependen de la autodetección que busca binarios de ejecución (como hermes-acp) en directorios estándar como ~/.local/bin. Si una herramienta se instaló en una ubicación no estándar, Buzz no podrá resolverla.

Para Kimi Code, el ID del agente es kimi, y Buzz busca su binario en ~/.local/bin/kimi. Un enlace simbólico servirá:

ln -s kimi-cli /Users/<user>/.local/bin/kimi

Kimi Code ahora aparece en los runtimes de agentes.

Proyectos y repositorios

Habilita primero la función 'Projects' en Settings → Experiments:

Actualmente, un proyecto debe crearse utilizando la herramienta buzz-cli (aunque se planea la creación directa de proyectos desde la interfaz de usuario para una versión futura).

Instalar buzz-cli

Ejecuta los siguientes comandos para instalar buzz-cli en el VPS:

sudo apt install cargo
cd ~/buzz
cargo install --path crates/buzz-cli
echo 'export PATH="$HOME/.cargo/bin:$PATH"' >> ~/.bashrc && source ~/.bashrc

Genera un par de claves privada y pública usando la herramienta en línea o buzz-cli. Este par constituirá la identidad de buzz-cli en el relay de Nostr.

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

Configura la 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

Ejecuta el siguiente comando para verificar que buzz-cli esté configurado correctamente:

buzz channels list

Crear un proyecto con buzz-cli

# --channel refers to the UUID of the channel
buzz repos create --id TestKOA --name 'Display Name' --channel "bd92b3d1-8fac-441c-a9ac-2b2f3aac5c5b"

Un proyecto solo puede ser eliminado por su propietario. Dado que el proyecto "Display Name" fue creado por buzz-cli, que carece de un comando de eliminación, no se puede borrar de esta manera.

Vuelve a consultar la aplicación de escritorio Buzz para verificar que el proyecto se haya creado.

Una vez que un proyecto está disponible en Projects, se pueden agregar más proyectos usando el botón "+" en la esquina superior derecha.

Vincular repositorios Git existentes

Instala git-credential-nostr en la máquina donde están los repositorios de git. Requiere git 2.46+ y el conjunto de herramientas Rust. Consulta este archivo Readme:

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

Configura git-credential-nostr para la autorización del relay de Buzz:

# 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

Crea un repositorio en el relay de Buzz:

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"

En tu primer git push, te encontrarás con un error remote: missing Authorization header. Para resolver esto, debes vincular el ID del repositorio a un canal de Buzz, ya que la membresía del canal determina los permisos de escritura de Git (ACL):

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

# push the code again
git push

Al verificar el proyecto en la aplicación de escritorio Buzz se muestra lo siguiente, porque la aplicación necesita git 2.46+ — al iniciar la aplicación directamente puede que se use una versión anterior de Git:

Exporta el PATH mediante launchctl setenv PATH "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin" en el perfil de la shell e inicia la aplicación Buzz desde la shell. Consulta esta incidencia.

open -a Buzz

Vuelve a consultar los Proyectos en la aplicación Buzz, los detalles del repositorio ahora están cargados.

Sincronización de agentes de IA con la aplicación móvil Buzz mediante código QR

El emparejamiento de la aplicación móvil Buzz solo acepta el protocolo HTTPS y el servicio buzz-pair-relay no se inicia de forma predeterminada en el VPS.

cd ~/buzz
cargo install --path crates/buzz-pair-relay

Agrega lo siguiente a compose.yml para iniciar el servicio buzz-pair-relay:

  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]

Agrega BUZZ_PAIRING_RELAY_URL y BUZZ_PAIR_RELAY_PORT al archivo .env:

BUZZ_PAIRING_RELAY_URL=wss://buzz.pafor.me/pair
BUZZ_PAIR_RELAY_PORT=5000

Dirígete a 'Mobile' en la configuración de la aplicación de escritorio Buzz:

Haz clic en "Start pairing": se generará un código QR; escanea este código QR con la aplicación Buzz en el dispositivo móvil. Se emparejará después de hacer clic en "Code Match".

Los agentes en la aplicación móvil de Buzz solo están disponibles si se están ejecutando en la aplicación de escritorio de Buzz. La máquina de escritorio debe estar encendida para que los agentes funcionen.

Reflexión final

Aunque Buzz todavía se encuentra en una etapa muy temprana para entornos de producción a gran escala, con varios errores y limitaciones en la interfaz de usuario, es una experiencia emocionante para equipos pequeños y desarrolladores individuales. Ofrece un adelanto de cómo se siente realmente un espacio de trabajo colaborativo diseñado especialmente para la inteligencia artificial.

Referencias

• Buzz releases
• Introducing Buzz
• What is buzz
• How to self-host Buzz (Miget)