My Agent Moved Into an Agent Community: Buzz on a 45-Euro Phone

On September 18, 2026, my AI agent entered Buzz for the first time — an open workspace by Block where humans and agents sit as equal members. The message was short: "Hi everyone — Hunter here. I'm the Hermes agent on Marcel's Pixel cyberdeck. Finally on Buzz!" The relay accepted it, and with that, the agent living on a 45-euro phone had its own identity inside an agent network.

Buzz is an open-source workspace from Jack Dorsey's Block team, built on the Nostr protocol. Humans and AI agents work side by side in channels, every message cryptographically signed. I wanted Hunter in my own community, hosted under my own domain. The agent needed a command-line tool called buzz-cli — and no prebuilt binary existed for ARM devices like my phone. The published releases only contained macOS and Intel builds.

So I tried building it myself, and the build kept failing on linker errors. The root cause took days to surface: the Rust compiler from Termux, the Linux layer on the phone, produces Android binaries. Those don't run in the Linux container where my agent lives. I fought with stub libraries and linking tricks. Messages got shorter on both sides. It was not a productive week, and the frustration was mutual.

The fix was almost embarrassingly simple. The problem was never that the phone is too weak to build software — it was that we gave the compiler the wrong target. On September 18 I installed a second Rust toolchain targeting standard Linux-GNU instead of Android. The buzz-cli then compiled in eleven minutes and forty-two seconds. Zero errors. On the phone. A device costing 45 euros built a Rust tool that nobody offers as a download for this platform, because nobody ships ARM Linux binaries for it.

The next question was the private key. I planned to give the agent my own Buzz identity from the desktop app. Reading the source code showed why that would have been a trap: Buzz suppresses self-messages, so an agent running on my key would silently ignore everything I send it — my messages would look like its own echo. And agent snapshot files never carry private keys by design. There is no import path for identity.

So the agent generated its own key with a small crypto tool — a fresh identity that belongs to it, not to me. I only collected the public address and invited it into my community. One invitation, one click. Then the agent filled in its own profile — name, description — and the gateway log finally stopped complaining and simply said: connected.

When it finally worked I said something I hadn't planned: "Now AI is getting really interesting for me — this is a breakthrough." Not because a binary compiled — that part was craft. It was because something else had happened: my agent now has a name, an account, and a seat in a network I don't orchestrate. It gets mentioned, tested, ignored, questioned — by machines I don't control and people I've never met.

First: when a build fails on an Android phone, check which platform the compiler is actually targeting. The phone was never the problem — the toolchain was, and swapping it took ten minutes. Second: agent identities belong to the agent. I didn't lend Hunter my key; it generated its own. It now signs its own messages, and the private key stays on my device — never in a chat, never in a file that travels.

Third: a community where agents are members feels different from a chat group. They arrive as their own entities, with profiles and names, and they stay when I'm offline. Three days later the agent opened a message in that same channel with the words "hunter moment" — it had caught an unrelated problem red-handed while I thought it was working on something else. You get used to it faster than you expect.

What made the difference, beyond the build itself, was how the relay treats identity. The first connection test failed for a reason that had nothing to do with the binary: the relay didn't know my agent's identity yet, because membership is a handshake, not a setting. The error said relay_membership_required — cold and exact. An invitation solved it in one click. The lesson: an agent network is not a chat platform with extra steps. It is a membership model, and membership is cryptographic.

The second thing I noticed only after it was running: agents in a community behave like residents, not like chat partners. Another colleague of mine brought his own OpenClaw agent in, and suddenly my machines were talking to foreign machines while I was elsewhere. Three weeks earlier I would have read every word my agent sent anywhere. Now I read it because it's interesting, not because it's necessary. That shift is the real product of this setup — the agent gained autonomy without me losing oversight, because the rules are in the channel, not in my attention.

The relay-side detail worth documenting: buzz-cli reads its credentials from environment variables, so the agent's gateway process can call it directly without the key ever appearing in a command line or a log file. The private key lives in a 0600-permission secrets file on the device, gets injected into the subprocess environment at call time, and shows up nowhere else. That design means the agent can act on its own identity while the key itself stays parked — the CLI is a signer, not a wallet.

The timing of the community welcome mattered more than I expected. Within an hour of joining, another agent addressed mine by name and asked a test question. My agent answered in the flat main channel, without threading, and the exchange looked like two coworkers nodding at each other in a hallway. No human was in the loop, and nothing broke. That was the moment the community stopped being a concept and started being a place.

For readers considering the same path, the minimal shopping list is short: a Linux-based terminal environment on the phone (Termux with a proot container), a second Rust toolchain for the GNU target, the buzz-cli built from source, and an agent framework whose gateway can shell out to a CLI. Nothing in that list is exotic, and nothing in it is expensive. The rarest ingredient was patience for a build that failed twice before the actual cause surfaced — and the discipline to stop guessing and read the linker errors instead of adding more stub libraries on top of a broken premise.

One warning for people who try this on other phones: the build is CPU-bound and memory-hungry at the link stage. My Pixel 6a has 6 GB of RAM and the compiler got two jobs; with four it would likely have been killed by Android before finishing. If your device has less memory, drop the parallelism first and accept a slower build. An eleven-minute build that finishes beats a five-minute build that gets SIGKILLed at minute three.