---
title: "Cómo autoalojar Buzz de Block: Espacio de trabajo para agentes IA"
description: "Aprende a autoalojar el relay de Buzz en un VPS con Ubuntu detrás de Cloudflare. Crea un espacio de trabajo seguro donde humanos y agentes de IA colaboran."
canonical_url: "https://techvoyage.dev/es/article/self-hosting-buzz-as-the-workspace-where-ai-agents-become-colleagues"
last_updated: "2026-10-20T09:53:45.216Z"
---
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](/article/exposing-hermes-agent-to-private-network-using-cloudflare-warp). La pila consta de cuatro servicios en Docker Compose (relay, PostgreSQL, Redis y MinIO) además de Caddy para HTTPS.
### 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**.
1. Haz clic en **Create Token**.
2. Usa la plantilla **Edit zone DNS**.
3. Configura la plantilla de la siguiente manera:
- **Permissions**: Zone — DNS — Edit
- **Zone Resources**: Include — Specific zone — `example.com`
4. Haz clic en **Continue to summary**.
5. Haz clic en **Create Token**.
6. Copia el token generado, ya que no se volverá a mostrar una vez cerrada la página.
7. Prueba el token generado en tu terminal para asegurarte de que funciona correctamente:
```bash
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:
```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. Clonar y configurar
```bash
git clone https://github.com/block/buzz.git
cd buzz/deploy/compose
cp .env.example .env
nano .env
```
Edita `.env` en grupos:
- **Dominio:**
```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
```
- **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](/es/tools/secret-key-hex) 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`.
```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
```
- **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:
```yml
{
acme_dns cloudflare {env.CLOUDFLARE_API_TOKEN}
}
```
- Crea un Dockerfile.caddy con el siguiente contenido, el cual es requerido por compose.caddy.yml:
```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:
```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
```
#### Iniciar los contenedores de Docker
```bash
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
```bash
mkdir -p /buzz_backups
crontab -e
```
Agrega una tarea cron nocturna para el volcado de la base de datos:
```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
```
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](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:
```bash
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á:
```text
ln -s kimi-cli /Users//.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**:
```bash
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](/es/tools/nostr-key-generator) o `buzz-cli`. Este par constituirá la identidad de `buzz-cli` en el relay de Nostr.
```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
```
Configura la 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
```
Ejecuta el siguiente comando para verificar que `buzz-cli` esté configurado correctamente:
```bash
buzz channels list
```
#### Crear un proyecto con buzz-cli
```bash
# --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](https://github.com/block/buzz/tree/main/crates/git-credential-nostr):
```bash
cargo install --path crates/git-credential-nostr
```
Configura `git-credential-nostr` para la autorización del relay de Buzz:
```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
```
Crea un repositorio en el relay de Buzz:
```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"
```
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):
```bash
buzz repos bind --id koa-email-routing --channel
# 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](https://github.com/block/buzz/issues/5348).
```bash
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.
```bash
cd ~/buzz
cargo install --path crates/buzz-pair-relay
```
Agrega lo siguiente a `compose.yml` para iniciar el servicio `buzz-pair-relay`:
```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]
```
Agrega `BUZZ_PAIRING_RELAY_URL` y `BUZZ_PAIR_RELAY_PORT` al archivo `.env`:
```text
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](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)