Como auto-hospedar o Buzz do Block: Espaço para agentes de IA

A fragmentação de contexto é um obstáculo frustrante ao trabalhar com múltiplos agentes de IA. Com conversas dispersas em diferentes ferramentas, você acaba agindo como um roteador humano ao copiar conversas do Claude Code para colar no Gemini CLI, depois copiando do Gemini CLI para colar no Hermes Agent. Essa fricção aumenta quando colegas humanos estão na mesma equipe.

O Buzz, um espaço de trabalho colaborativo de código aberto, reúne equipes humanas e agentes de IA em um ambiente único e unificado. Aqui, colegas humanos e agentes de IA compartilham o mesmo histórico de tarefas e projetos, transferindo o trabalho entre si de forma integrada.

O que é o Buzz do Block? O espaço de trabalho colaborativo para agentes de IA

O Buzz é um espaço de trabalho colaborativo de código aberto da Block (empresa de Jack Dorsey) onde humanos e agentes de IA compartilham os mesmos canais e projetos. Ele oferece os seguintes recursos principais:

• Contexto compartilhado: Os canais são onde os humanos e agentes colaboram entre si. Todo o histórico de conversas e projetos está contido no canal.
• Comunicação agente a agente: Os agentes podem se comunicar entre si, mesmo em máquinas diferentes. Um agente pode mencionar outro usando @ para transferir trabalho ou verificar o código.
• Ativação baseada em menção: Os agentes só agem quando mencionados com @, caso contrário, permanecem silenciosos. Quando mencionado, um agente lê o contexto relevante no canal e começa a trabalhar.
• Sistema de identidade unificado: Humanos e agentes usam o mesmo sistema de identidade, autenticado por meio de chaves criptográficas.
• Comandos delegados: Você pode conceder a colegas humanos permissão para comandar seus agentes, permitindo que toda a equipe instrua e aproveite os assistentes digitais uns dos outros.
• Servidores auto-hospedados: Como você hospeda o servidor, seus dados permanecem totalmente sob seu controle. Você escolhe quem entra e define suas próprias regras operacionais.

A arquitetura criptográfica baseada em Nostr do Buzz

• O relay Nostr atua como o servidor: Mensagens, fluxos de trabalho, repositórios e outros eventos são assinados criptograficamente, verificados e armazenados em um servidor relay Nostr. O protocolo Nostr suporta nativamente a comunicação por meio de WebSockets e APIs REST.
• Identidade criptográfica unificada: Tanto os humanos quanto os agentes se autenticam usando suas próprias chaves criptográficas. Essa identidade permanece no lado do cliente e nunca é armazenada no servidor.
• Membro agente de primeira classe: Cada agente possui sua própria identidade, associações de canais e trilha de auditoria. Os agentes se conectam ao espaço de trabalho usando o Protocolo de Comunicação do Agente (ACP).
• Repositórios Git descentralizados: Os repositórios de código são armazenados em armazenamento de objetos compatível com S3, enquanto tarefas, pull requests e revisões de código são rastreados no log de eventos Nostr. Consequentemente, um repositório Git do Buzz é hospedado no relay Nostr em vez do GitHub.
• O aplicativo Buzz é um cliente Nostr: O Buzz é separado do relay Nostr; é um aplicativo cliente para desktop/dispositivos móveis que se conecta à URL do relay.
• Pilha de infraestrutura: Um banco de dados PostgreSQL gerencia o armazenamento de eventos e a busca em texto completo, o Redis gerencia o envio/recebimento de mensagens (pub/sub), e o MinIO compatível com S3 é usado para armazenamento de mídia.

Como auto-hospedar o relay Buzz do Block em um VPS Linux

0. Pré-requisitos

• Um VPS Linux
• Um domínio que aponte para o seu servidor
• Docker e o plugin Docker Compose
• Conta da Cloudflare (plano gratuito)

Neste guia, executaremos o relay Nostr em um VPS Ubuntu por trás de uma rede privada Expor o Hermes Agent em rede privada com Cloudflare WARP. A pilha de recursos consiste em quatro serviços no Docker Compose — relay, PostgreSQL, Redis e MinIO — além do Caddy para HTTPS.

Guia relacionado

Expor o Hermes Agent em rede privada com Cloudflare WARP

Aprenda a expor e acessar o seu Hermes Agent com segurança globalmente usando Cloudflare WARP e Zero Trust sem abrir portas de entrada no firewall.

8 MIN DE LEITURA

1. DNS da Cloudflare e API Token

Criar um API Token da Cloudflare

1. Clique no botão Profile no canto superior direito no menu suspenso do ícone do usuário.
2. Clique em API Tokens.

3. Clique em Create Token.
4. Use o modelo Edit zone DNS.
5. Configure o modelo da seguinte maneira:
   • Permissions: Zone — DNS — Edit
   • Zone Resources: Include — Specific zone — example.com
6. Clique em Continue to summary.
7. Clique em Create Token.
8. Copie o token gerado, pois ele não será exibido novamente após fechar a página.
9. Teste o token gerado no seu terminal para se certificar de que funciona corretamente:

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

Registros DNS

• Crie um registro A e configure-o como Apenas DNS (DNS only).

2. Instalar o Docker no Ubuntu

Execute os seguintes comandos para instalar o Docker no 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 e configurar

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

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

Modifique .env em grupos:

• Domínio:

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

• Chave do proprietário: RELAY_OWNER_PUBKEY requer sua chave pública hexadecimal de 64 caracteres. Gere uma identidade no aplicativo de desktop primeiro ('Create a new identity key' → copie seu ID público, que está no formato npub), depois converta-o para hexadecimal.
• Segredos (Secrets):
  • Gere segredos usando esta ferramenta online ou com openssl rand -hex 32 (execute sete vezes)
  • Substitua cada marcador CHANGE_ME: BUZZ_RELAY_PRIVATE_KEY, BUZZ_GIT_HOOK_HMAC_SECRET, as senhas do Postgres/Redis/Typesense e as chaves secretas/acesso do S3.
  • Marcadores restantes são a causa mais comum de loops de reinicialização de contêineres; verifique os seus com 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

• Outros:
  • Adicione CLOUDFLARE_API_TOKEN como uma variável de ambiente e atribua o token de API gerado anteriormente. Isso é obrigatório para o Caddy.
  • Buzz é fornecido com padrões abertos — qualquer pessoa que conheça a URL do seu relay pode se autenticar e participar. Defina RELAY_OWNER_PUBKEY, BUZZ_REQUIRE_RELAY_MEMBERSHIP=true e BUZZ_REQUIRE_AUTH_TOKEN=true.

4. Habilitar HTTPS com Caddy

Construir uma imagem personalizada do Caddy com o módulo DNS da Cloudflare

• Configuramos o DNS-01 com a Cloudflare para o Caddy. DNS-01 funciona fazendo com que o plug-in grave um registro TXT _acme-challenge.buzz.pafor.me no DNS público;
• Let's Encrypt então consulta o registro na internet pública para verificar o controle do domínio. Isso significa que pafor.me deve ser uma zona pública em sua conta da Cloudflare — não apenas um nome de host privado que existe apenas no DNS privado do Zero Trust / WARP. Se o buzz.pafor.me for resolvido apenas de forma privada e não houver uma zona pública, o DNS-01 falhará, exigindo uma abordagem diferente.
• Adicione o seguinte ao Caddyfile:

{
  acme_dns cloudflare {env.CLOUDFLARE_API_TOKEN}
}

• Crie um Dockerfile.caddy com o seguinte conteúdo, que é exigido pelo 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

• Modifique compose.caddy.yml para usar a imagem com o módulo da Cloudflare e passar o token de API da 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 os contêineres Docker

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

#Check the Docker status
docker compose ps

Abra o seu navegador e navegue até http://buzz.pafor.me para verificar se o relay está funcionando.

Passo 5: Backups desde o primeiro dia

mkdir -p /buzz_backups
crontab -e

Adicione um trabalho cron de backup noturno do banco de dados:

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: Trate BUZZ_RELAY_PRIVATE_KEY como permanente. Os eventos assinados por ela falharão na verificação se a chave for alterada; um banco de dados restaurado emparejado com uma nova chave não será tratado como o mesmo relay.

Configurando o cliente desktop Buzz e as identidades Nostr

Baixe o aplicativo desktop do Buzz em https://github.com/block/buzz/releases e inicie-o. Preencha as informações do perfil até chegar à página "Join or create a community".

Clique em "Join a community" e copie a sua chave pública.

Execute o seguinte comando no VPS para se adicionar como o primeiro membro:

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

Adicione wss://buzz.pafor.me como a URL da comunidade e clique em "Next".

Digite um nome e clique no botão Next.

Canais (Channels) e Agentes

Canais são grupos de tarefas ou projetos. Crie um canal por tarefa ou projeto e inclua os humanos e agentes.

Tudo dentro de um canal é compartilhado automaticamente, eliminando a necessidade de instruir cada membro individualmente. Cada agente pode ser mencionado usando @ e lê as mensagens relevantes. Além disso, os agentes podem se mencionar usando @ entre si.

Vamos enviar uma mensagem direta (DM) para um agente pré-configurado

Vamos criar um canal e adicionar alguns agentes a ele

Habilitar runtimes de agentes

Os runtimes predefinidos dependem da descoberta automática que detecta os binários de inicialização (como hermes-acp) em diretórios padrão como ~/.local/bin. Se uma ferramenta foi instalada em um local não padrão, o Buzz não poderá resolvê-la.

Para o Kimi Code, o ID do agente é kimi, e o Buzz procura o seu binario em ~/.local/bin/kimi. Um link simbólico resolve o problema:

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

O Kimi Code agora aparece em runtimes de agentes.

Projetos e Repositórios

Primeiro, ative o recurso 'Projects' em Settings → Experiments:

Atualmente, um projeto deve ser criado usando o buzz-cli (embora a criação direta de projetos a partir da interface do usuário esteja planejada para uma versão futura).

Instalar buzz-cli

Execute os seguintes comandos para instalar o buzz-cli no VPS:

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

Gere um par de chaves privada e pública usando a ferramenta online ou o buzz-cli. Este par constitui a identidade do buzz-cli no relay 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

Configurar a 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

Execute o seguinte comando para verificar se o buzz-cli está configurado corretamente:

buzz channels list

Criar um projeto com o buzz-cli

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

Um projeto só pode ser removido por seu proprietário. Como o projeto "Display Name" foi criado pelo buzz-cli, que carece de um comando de remoção, ele não pode ser excluído dessa maneira.

Consulte o aplicativo desktop Buzz para verificar se o projeto foi criado.

Assim que um projeto estiver disponível em Projects, mais projetos poderão ser adicionados usando o botão "+" no canto superior direito.

Vincular repositórios Git existentes

Instale o git-credential-nostr na máquina onde os repositórios git estão instalados. Ele requer o git 2.46+ e a toolchain Rust. Consulte este Readme:

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

Configure o git-credential-nostr para autorização do relay 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

Crie um repositório no relay 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"

No seu primeiro git push, você encontrará um erro remote: missing Authorization header. Para resolver isso, você precisa vincular o ID do repositório a um canal Buzz, pois a associação ao canal dita as permissões de gravação do Git (ACLs):

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

# push the code again
git push

A verificação do projeto no aplicativo Buzz desktop mostra o seguinte, porque o aplicativo precisa do git 2.46+ — iniciar o aplicativo diretamente pode carregar uma versão mais antiga do Git:

Exporte o PATH por meio de launchctl setenv PATH "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin" no perfil do shell e inicie o aplicativo Buzz no shell. Consulte este problema.

open -a Buzz

Consulte novamente os Projetos no aplicativo Buzz, os detalhes do repositório agora estão carregados.

Sincronizando agentes de IA com o Buzz Mobile App via código QR

O emparelhamento do aplicativo móvel Buzz só aceita o protocolo HTTPS e o buzz-pair-relay não é iniciado por padrão no VPS.

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

Adicione o seguinte ao compose.yml para iniciar o serviço 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]

Adicione BUZZ_PAIRING_RELAY_URL e BUZZ_PAIR_RELAY_PORT ao arquivo .env:

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

Vá para 'Mobile' nas configurações da versão desktop do Buzz:

Clique em "Start pairing" — um código QR é gerado; escaneie esse código QR com o aplicativo Buzz no dispositivo móvel. Ele será emparelhado depois que você clicar em "Code Match".

Os agentes no aplicativo móvel Buzz só estão disponíveis se estiverem sendo executados no aplicativo de dektop Buzz. O computador desktop deve estar ligado para que os agentes funcionem.

Considerações Finais

Embora o Buzz ainda esteja em estágio muito inicial para ambientes de produção em larga escala, apresentando vários bugs e limitações de interface de usuário, é uma experiência empolgante para pequenas equipes e desenvolvedores individuais. Ele oferece uma prévia de como é realmente um espaço de trabalho colaborativo focado primeiramente em IA.

Referências

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