---
title: "Como auto-hospedar o Buzz do Block: Espaço para agentes de IA"
description: "Aprenda a auto-hospedar o relay Buzz da Block em um VPS Linux com Cloudflare. Crie um espaço de trabalho seguro baseado em Nostr para humanos e agentes IA."
canonical_url: "https://techvoyage.dev/pt/article/self-hosting-buzz-as-the-workspace-where-ai-agents-become-colleagues"
last_updated: "2026-10-20T09:53:42.948Z"
---
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](/article/exposing-hermes-agent-to-private-network-using-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.
### 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**.
1. Clique em **Create Token**.
2. Use o modelo **Edit zone DNS**.
3. Configure o modelo da seguinte maneira:
- **Permissions**: Zone — DNS — Edit
- **Zone Resources**: Include — Specific zone — `example.com`
4. Clique em **Continue to summary**.
5. Clique em **Create Token**.
6. Copie o token gerado, pois ele não será exibido novamente após fechar a página.
7. Teste o token gerado no seu terminal para se certificar de que funciona corretamente:
```bash
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:
```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 e configurar
```bash
git clone https://github.com/block/buzz.git
cd buzz/deploy/compose
cp .env.example .env
nano .env
```
Modifique `.env` em grupos:
- **Domínio:**
```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
```
- **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](/pt/tools/secret-key-hex) 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`.
```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
```
- **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:
```yml
{
acme_dns cloudflare {env.CLOUDFLARE_API_TOKEN}
}
```
- Crie um Dockerfile.caddy com o seguinte conteúdo, que é exigido pelo 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
```
- Modifique `compose.caddy.yml` para usar a imagem com o módulo da Cloudflare e passar o token de API da 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 os contêineres Docker
```bash
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
```bash
mkdir -p /buzz_backups
crontab -e
```
Adicione um trabalho cron de backup noturno do banco de dados:
```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: 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](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:
```bash
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:
```text
ln -s kimi-cli /Users//.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:
```bash
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](/pt/tools/nostr-key-generator) ou o `buzz-cli`. Este par constitui a identidade do `buzz-cli` no relay 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
```
Configurar a 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
```
Execute o seguinte comando para verificar se o buzz-cli está configurado corretamente:
```bash
buzz channels list
```
#### Criar um projeto com o 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"
```
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](https://github.com/block/buzz/tree/main/crates/git-credential-nostr):
```bash
cargo install --path crates/git-credential-nostr
```
Configure o `git-credential-nostr` para autorização do relay 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
```
Crie um repositório no relay 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"
```
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):
```bash
buzz repos bind --id koa-email-routing --channel
# 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](https://github.com/block/buzz/issues/5348).
```bash
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.
```bash
cd ~/buzz
cargo install --path crates/buzz-pair-relay
```
Adicione o seguinte ao `compose.yml` para iniciar o serviço `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]
```
Adicione `BUZZ_PAIRING_RELAY_URL` e `BUZZ_PAIR_RELAY_PORT` ao arquivo `.env`:
```text
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](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)