Thesis

Arbe is a substrate for networked software where humans and machines share the same space, the same identity model, and the same permission rules. Most systems build these primitives accidentally — scoping, permissions, agent identity, and persistence get reinvented ad hoc by every collaboration tool, every agent framework, every chat product. Arbe makes them the explicit foundation and treats everything above as a swappable surface.

The value isn’t being Slack or a filesystem or an agent runtime. It’s being the thing that could host all of them in the same space, talking to each other, with a permission model that works across the whole mess. Every design decision is tested against this: does it keep the primitives general, or does it bake in assumptions about what agents are and how they work?

Every collaborative system independently approximates the same substrate.

Slack has channels, rooms, workspaces, bots, permissions, and an event log. A filesystem has directories, files, processes, users, rwx, and an audit trail. An AI coding session has a project, a conversation, an agent, tool calls, permission prompts, and a transcript. They use different words. They describe the same six things: records (the entities), streams (the content), agents (who participates), permissions (what they can do), mutations (what changed structurally), and signals (what the system experienced while doing all of that).

The divergence between systems is accidental, not essential. Products start at the metaphor layer — channels, folders, sessions — and build downward toward the substrate they need. The substrate is always the same. The metaphors calcify into architecture, making the systems incompatible despite being formally equivalent.

The two layers

Every networked system has them, whether or not they’re made explicit:

Formal layer — the irreducible substrate. Records, streams, agents, permissions, mutations, signals. This is what you actually build. It doesn’t change when the product changes.

Cognitive layer — the metaphors that make the primitives legible to a particular user group. Channels, workspaces, sessions, assistants, projects. This is what users see. It should be swappable without rewriting the substrate.

Knowing you’re choosing a metaphor changes how you build. Your channels stop being load-bearing. You can ship a new surface — a CLI, a coding agent, a dashboard — without reimplementing scoping, permissions, and identity from scratch. Constraints free you.

Why this matters now

AI agents are not a new category of participant. They’re agents — records with identity, permissions, and a runtime. An LLM reply and a human message are the same operation at the stream layer: a participant with w appended to the room’s log.

LLMs are the first class of agent powerful enough to make the substrate matter. Shell scripts could always be “agents” in a Unix system, but they were too dumb to need real permissions, memory, or coordination. LLMs are smart enough to be dangerous without those things. One agent might participate in thousands of rooms simultaneously, spawn subagents, invoke tools, write code. Ad hoc permission models, ephemeral session state, and implicit trust don’t scale to that. The substrate is suddenly load-bearing in a way it wasn’t before.

The formal layer handles it cleanly. Permissions inherit down the scope tree. Sub-agent coordination is @mentions in a shared stream — no new infrastructure. An agent asking “can I delete this file?” is permission escalation as a stream protocol, not a special API.

The symmetry is in identity and authorization, not in embodiment. A human and a bot are both agents with rwx on scopes — same permission resolver, same RLS enforcement, same audit trail. Their execution environments differ (a browser vs a Durable Object with SQLite and an LLM), and that’s fine. Arbe equalizes participation, not runtime.

The sixth primitive

The original five describe what exists (records), what participants say (streams), who acts (agents), what they’re allowed to do (permissions), and what changed structurally (mutations). But every system also produces a category of data that fits none of these: operational execution metadata. Latencies, retries, decisions, failures, activations. Not content — nobody reads it to understand the conversation. Not structure — nothing was created or moved. Not a permission change. The system witnessing its own operation.

This is easy to miss as a primitive because it’s parasitic on the other transport mechanisms. Observability events often travel as stream messages or look like mutations. But their purpose is different. A stream message records what a participant intended. A signal records what the system experienced while carrying that intent.

The constraint that makes this clean: every write already has an agent_id. Humans and bots are both agents with UUIDs. The CLI user is an agent in arbe. Signals already have identity and authorship — they just didn’t have a named primitive to carry them.

Code is ephemeral. The substrate isn’t.

Fowler’s “immortality of intent, not code” maps directly here. The stream is the intent — the durable record of what happened, who decided what, and why. The code that runs agents, renders UIs, and processes events is disposable. Regenerate it. The stream survives.

This is what makes the substrate worth building carefully. Not because the code is precious, but because the primitives underneath it are.

How the system grows

Each new capability extends the system by adding content to existing record types, new record types that slot into the existing permission model, or new activation paths into the existing agent contract. The substrate stays the same.

Known seams, not universal coverage

The primitives are more universal than most people think. But universality isn’t the goal — intentionality is. Plan 9 said “everything is a file” and mostly meant it, but Pike was explicit about where it broke down: you can’t cp a binary into /proc to run a process. The metaphor has a boundary, and naming it was more valuable than pretending it didn’t exist.

The practical learning: design around the primitives hard, but mark the edges clearly rather than stretching to cover them. A seam that’s intentional and documented is fine. A seam that’s accidental and hidden is where systems quietly become incompatible with themselves.