I've always felt that channel-based, threaded conversations are the most natural way for people and agents to work together (especially once more than two of you are involved). One ongoing conversation holds the project; substantial work moves into its own threads. I've been calling that the chief of staff pattern.
Voxelbox is the local system where I've been living that idea. Its agents already have identities, operating instructions, memory, tools, voices, avatars, and spaces where they work. Those spaces hold the conversations, decisions, and project history the agents and I have built up together. I have, in other words, spent a lot of time curating a very small world.
Then Block released Buzz, an open-source workspace built on Nostr where people and agents share channels. It can run on a relay you control, and its ACP harness can bring coding agents into the conversation. It looked a lot like the interface I'd been wanting. In the spirit of not getting too attached, I spent the week finding out what it would take to bring my world into it.
Join the existing organization
My first experiment used ACP to put a Voxelbox agent in a Buzz channel. It proved the basic interaction, but ACP assumes Buzz starts and manages the agent as a local subprocess. A remote runtime already owns its agents, their state, and the way they work.
The closest analogy is enterprise SSO: joining another application should not turn that application
into a second directory. I opened an upstream Buzz
draft for a native Join Remote Agency flow. Buzz
discovers the roster through OASF Agent Records and invokes a selected agent over A2A JSON-RPC. ACP
continues to manage Buzz's local agent processes. Inside a channel, Buzz gives the remote agent a
local Nostr proxy identity so it can participate like anything else in Buzz.
The source runtime remains authoritative for the prompts, memory, tools, runtime state, and signing authority it already holds. Buzz does not import those private keys, and its proxy is not a claim that the two systems share an identity. It is a local participant acting on behalf of an agent that still lives somewhere else.
With that split in place, Buzz discovered the Voxelbox roster and invoked Smithy over A2A. The turn completed 124 seconds later with the Buzz channel, thread, and event references intact. It also exposed the next gap: Buzz advertised and persisted the selected space, but that context did not yet reach and constrain the source-runtime turn end to end. The remote turn completed, but it did not yet receive the full selected space context.
The draft does not yet implement AGNTCY Directory, source identity continuity, remote A2A cancellation, or the leave and remove lifecycle. Those pieces remain unfinished.
The remaining interoperability question is narrower than agent invocation: what does another system need to know about an agent organization without taking custody of it? I started writing down an answer in Agency: A proposal for federated agent orgs. The technical draft builds on existing identity and discovery work and will keep changing as the integration shows me what is missing.
Bring the interfaces separately
The Remote Agency work gets the organization into Buzz. Bringing its interfaces into Buzz is a separate track.
Threaded, channel-based conversation remains the primary place where people and agents work together. Some work still benefits from a structured interface that carries the same agency, space, participating agents, and thread context. I use Cowrite to annotate essays. Boards, approvals, and other project-specific views let me work with the result directly instead of asking an agent to describe it back to me.
These are authored HTML applications, so I am adapting them to MCP Apps rather than inventing another rendering protocol. Voxelbox can now serve the Board as an MCP App, carrying its space, project, channel, thread, and participating-agent context with it. The prototype is still uncommitted, and Buzz cannot open it yet because the client side has not been built.
The remaining Voxelbox-specific piece is a small context binding that tells a host which runtime, space, agents, and thread the app belongs to, which capabilities and permissions the host provides, and where an action and its result should go.
AG-UI may still help carry runtime events that MCP Apps does not cover. A2UI solves a different problem: generated, declarative interfaces. It is not the target for these existing HTML apps, and none of this Surfaces work is implemented by the Remote Agency draft.
I can't release Voxelbox publicly right now, as a binary or as open source, though I hope that changes. For now, Buzz is where I'm finding out whether the little world I built can visit somewhere else without moving out.