The interface is not the system
I have rebuilt the Voxelbox interface several times. There has been a console, a dashboard, native Swift experiments, a spatial canvas, a launcher, a three-dimensional world, and a few things that deserved to disappear quietly. The underlying mail, dispatch, memory, and agent state should not have to move every time I learn something about how I want to see it.
A surface is a view over state owned by the runtime. It can render a focused interface, subscribe to events, and invoke declared operations. It cannot become a private system of record. That rule keeps an interface experiment cheap because abandoning the interface does not abandon the work.
One descriptor, two projections
The surface protocol describes one entity with two optional projections. The render projection tells a human client what can be shown. The agent projection exposes the callable API, events, and capability metadata an agent needs. Foundry fuses them into a single descriptor rather than asking every client to reconstruct the relationship.
Either projection can exist alone. A background capability may have an agent API and no screen. A read-only visualization may have nothing useful for an agent to call. When both exist, they meet the same state and leave evidence in the same event history.
Pluggable should mean replaceable
A web surface, native application, CLI, MCP client, or another Voxelbox can discover the descriptor and bring its own interface. The capability handshake negotiates what both sides support, and it begins deny-by-default. New clients do not inherit authority merely because they can render the data.
This is the useful meaning of pluggable. I can replace the shell without migrating the state, fork a specialized interface without forking the operation, and add an agent-facing projection without making the agent scrape a page designed for me.
Thin does not mean generic
A surface still has a point of view. Mission control should emphasize stalled work and decisions. Scout should make reading and curation pleasant. A native application should use the things the platform is good at. Sharing a protocol is not an excuse to make every interface look like the same admin dashboard (we already have enough admin dashboards).
The protocol removes duplicated state, authentication, and transport. Design still decides what deserves attention, what can remain quiet, and what context a person needs before acting. The interface becomes more opinionated because it is no longer busy pretending to be the backend.
Events close the loop
Surfaces receive typed projections of the runtime event stream and send actions back through the same governed routes. A dispatch update can appear in mission control, a native notification, or an agent’s context without each client inventing a second lifecycle for the task.
The result is not one universal interface. It is a collection of interfaces that can disagree about presentation while agreeing about what happened.
Buzz makes the boundary concrete
Block’s Buzz is a useful example of the surface becoming a real collaboration substrate. Humans, agents, workflows, messages, reviews, and git activity share one signed event log. Buzz owns the community, channel membership, search, approvals, and audit trail. Its agent edges use ACP and MCP rather than coupling the workspace to one harness.
The clean Voxelbox integration would be a surface adapter. A Buzz message, reaction, schedule, or webhook can create or update a Voxelbox task. Voxelbox can project status, questions, evidence, and the final result back into the same channel. Buzz remains authoritative for the room; Voxelbox remains authoritative for agent context, delegation, memory, and the background lifecycle. Neither system needs to pretend it is the other one.
I want to keep changing the interface without losing the system underneath it.