I Self-Hosted Block's Buzz Relay on a DGX Spark (arm64 Desktop, Phone)
On 2026-11-12 I stood up a self-hosted relay for Buzz (Block’s open-source workspace for humans and AI agents on Nostr) on a DGX Spark, built the desktop client from source for ARM64 Linux, connected a phone, and opened an upstream pull request with Linux arm64 installers. This article documents the path so others can replicate it. It is also the public reference for my upstream contribution (block/buzz-app#3368) and the coming sovereign-fleet integration.
Buzz is Apache-2.0. Every participant, human or agent, gets its own keypair. Messages, approvals and git events are signed Nostr events in one log. Agents join through harnesses like goose, Codex, Claude Code and Pi, or through the buzz CLI. Desktop 1.0.0 shipped on 2026-11-10; desktop app and relay are both open source on GitHub (links at the end).
A hosted option called Builderlab exists. It gives 100 GB storage and delivery per month per workspace, keeps content for 365 days, and is not end-to-end encrypted per buzz.xyz/support. I self-host instead.
Why Buzz next to the fleet
My fleet already has its ways in: a dashboard that works on the phone, an MCP server any agent can call, and Gitea and GitHub issues. What none of them is: a shared room. In Buzz I post a task in a channel, people and agents discuss it in the thread, and every message, the fleet’s answer included, is signed and stays in one log.
goose is built into Buzz, so why not let it do the work right there? Because an available agent is not the point. The point is what happens before a change counts: each task runs in its own git worktree inside a Landlock sandbox, the router picks a model lane per task, and nothing lands until the project’s tests pass. The fleet runs goose too; it adds the sandbox and the gate around it.
So Buzz is the front and the fleet is the workbench behind it. Next, the goose agent in Buzz gets the fleet’s MCP server as a tool: it answers quick questions itself and hands work that has to ship as tested code to the fleet. The fleet replies in the thread with its own key, so anyone in the room can check who did what. That part is being built now.
The relay on DGX Spark
The DGX Spark is an ARM64 machine (GB10). The relay image is multi-arch and includes a linux/arm64 variant. I use the upstream Compose bundle from deploy/compose. It runs four containers: relay, Postgres 17, Redis 7, and Silo (a maintained MinIO fork) for media and git objects.
My changes to that bundle:
- The relay image is pinned to a commit tag (
sha-0e6037c). No semver relay image exists yet. - All ports are bound to
127.0.0.1only. Nothing listens on the public interface. - Data is stored as bind mounts under one directory so the nightly encrypted backup covers everything.
- Secrets go in a separate file with 0600 permissions, created once by a setup script that never prints them.
- Mobile push is disabled. It would route device tokens through Block’s gateway.
The relay is reachable only inside my private WireGuard-based tailnet through a small Caddy instance with a Let’s Encrypt certificate. It is a closed relay (members only, NIP-42 auth) and is owned by my key.
First start is fast. Database migrations take 773 ms. The git object-store conformance probe passes in 6.8 s. All four containers report healthy. Liveness checks return 200 both locally and over the tailnet.
The relay’s NIP-11 document lists NIPs 1, 2, 10, 11, 16, 17, 23, 25, 29, 33, 38, 42, 50, 56, 43. It does not list NIP-34.
Backups and updates
Backups are nightly, on top of the encrypted backup system I rebuilt in April. I run pg_dump in custom format before the encrypted tar. The dump is checked with pg_restore -l. I keep two copies.
The first dump (482 KB) restored into a throwaway Postgres gave 103 tables and 86 migrations, the same as live.
Updates are split by component. Postgres and Redis move through the weekly image updater. The relay and Silo are pinned and move only on purpose. I do not let automatic updates touch the relay or the object store.
Desktop on ARM64 Linux
Upstream ships macOS, Windows and Linux x64 only. No ARM64 build exists. I built it from source on the Spark.
The build process is pinned by the repo’s Hermit toolchain. I set the version the same way upstream release CI does:
RELEASE_VERSION=1.0.0 node scripts/candidate-version.mjs
pnpm tauri build --bundles deb --config candidate.json
The result is one .deb, version 1.0.0, 86.5 MiB, arch arm64. It depends on libwebkit2gtk-4.1-0 and libgtk-3-0.
The four executables upstream CI checks (Buzz, goose-acp, buzz-agent-command, buzz) are all ELF aarch64. buzz --help runs. The cold build’s final cargo release step took 5 min 4 s.
Without Block’s updater key the in-app updater is off. The package cannot update itself.
Build dependencies on Ubuntu:
libasound2-dev libayatana-appindicator3-dev libgtk-3-dev librsvg2-dev libopus-dev libssl-dev libwebkit2gtk-4.1-dev libxdo-dev patchelf
The AppImage also builds (aarch64 appimagetool 1.9.1 and runtime 20251108, pinned by SHA-256) and passes the same checks.
I opened an upstream PR with Linux arm64 deb and AppImage installers: block/buzz-app#3368.
The crash and the fix
Clicking “Other options” (the self-hosted route) crashed Buzz with SIGSEGV. I spent time tracing it with apport core dumps and Ubuntu’s debuginfod symbols.
The cause is my own session-wide WEBKIT_DISABLE_DMABUF_RENDERER=1. I set it back in September so another Tauri app, Rayburst, would paint at all on the GB10. It makes WebKitGTK 2.52 skip its accelerated backing store. The web process still switches to accelerated compositing on the animated view change (document.startViewTransition). The UI process then calls AcceleratedBackingStore::update() on a null pointer. Callers only assert, also on WebKit main.
Compositing off and CPU rendering did not help. The fix is DMA-BUF renderer on, buffers over shared memory (WEBKIT_DMABUF_RENDERER_FORCE_SHM=1) in Buzz’s launcher.
This is already known upstream. WebKit bug 324730 is open with no patch. I added a comment with the root cause, a 30-line PyGObject repro and the workaround to block/buzz-app#2931. block/buzz#5768 proposes an app-side guard that skips the view transition on Linux.
The phone
The official Buzz app on Google Play offered me two ways in: scan a QR code, or sign in with email, which is the Builderlab route. For a self-hosted relay it is the QR code, and its payload carries a private key (buzz:// plus base64url of relayUrl and nsec). Without the key the app refuses.
So the phone got its own key. I generated it on the Spark with nak, stored it 0600, and added it to the relay as admin. I showed it only as a terminal QR code and scanned it with the app’s own scanner. The camera app would keep a photo of the key, so I avoided it.
Over the tailnet it connected within seconds. The desktop signs in with the same key.
The relay members break down like this:
- Owner. My main key, from config.
- Admin. Phone and desktop.
- Member. The fleet’s own key, created by a script that prints only the npub.
In the CLI, @name mentions must match a channel member.
The CLI
Nostr is not new on this grid, I already post to it automatically; Buzz is the first time agents and I share a room there. The buzz CLI against the relay works for channels create, messages send (also —reply-to), reactions add and messages get. Messages are kind 9 events with the channel in an h tag. Replies carry an e tag marked reply. These outputs are the test fixtures of sovereign-fleet’s Buzz intake.
How sovereign-fleet is built is in its architecture post, and why its gates matter more than an agent’s claims is in this one.
Self-hosted instead of Builderlab
Builderlab is the easier start, for example for a team that runs no servers of its own. Compared to my relay it gives 100 GB of storage and delivery per month per workspace and keeps content for 365 days, so older messages disappear. It is not end-to-end encrypted: the support page says the operator can access content to run, secure or moderate the service. Sign-in goes through an email address, and an encrypted copy of the private key is stored with Builderlab.
In my case the relay carries agent tasks and private project talk, so I run it myself instead of renting it. The data sits in my nightly encrypted backup, the relay answers only on the tailnet, and only members get in. The price is the work in this article.
What is not solved yet
- The relay image tracks a commit tag rather than a release, because block/buzz publishes no semver relay image yet. An upgrade is a manual step: a new tag in the mirror list, then a restart.
- The relay does not list NIP-34 in its NIP-11 document, so ngit repositories do not live on it yet. Whether it accepts NIP-34 events anyway is not proven.
- Push notifications are off on purpose, so the phone shows new messages only when the app is open.
- The in-app updater can’t work on my arm64 build without Block’s signing key. Until #3368 or a later release ships arm64 packages, an update is a rebuild.
- The WebKit crash is worked around, not fixed. Any Linux machine where
WEBKIT_DISABLE_DMABUF_RENDERERis set, a common NVIDIA workaround, crashes Buzz on that screen until WebKit bug 324730 or the app-side guard lands. - The phone key lives on the phone. If I lose the phone, I remove that one member with
buzz-adminand pair a new key; my main key is not on the phone.
What is next
Sovereign-fleet becomes a member with its own key. It reads a channel with the buzz CLI and answers in the thread. Buzz desktop agents run only while the app is open; the fleet runs always, so a task I post from the phone gets picked up even when no desktop is on. The complete setup and 13-second live benchmark are documented in the sovereign-fleet on Nostr companion post.
Links
- Relay: https://github.com/block/buzz
- Desktop: https://github.com/block/buzz-app
- Hosted info: https://buzz.xyz/support
- NIP-34 (git collaboration on Nostr): https://github.com/nostr-protocol/nips/blob/master/34.md
- Sovereign-fleet: https://github.com/Sovgrid/sovereign-fleet