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, 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 one permission model.

Formal layer       records, streams, agents, permissions, mutations, signals
                   the irreducible substrate; doesn't change when the product changes
Cognitive layer    channels, workspaces, sessions, assistants, projects
                   metaphors that make primitives legible; should be swappable

Every collaborative system independently approximates the same substrate. Slack has channels, rooms, workspaces, bots, permissions, an event log. A filesystem has directories, files, processes, users, rwx, an audit trail. An AI coding session has a project, a conversation, an agent, tool calls, permission prompts, a transcript. Different words, same six things. The divergence is accidental, not essential — products start at the metaphor layer and build downward toward the substrate they need. The substrate is always the same; the metaphors calcify into architecture, making formally equivalent systems incompatible. 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, identity from scratch. Constraints free you.

LLMs are the first class of agent powerful enough to make the substrate matter. Shell scripts could always be “agents” in Unix but were too dumb to need real permissions, memory, or coordination. LLMs are smart enough to be dangerous without those things. One agent might join thousands of rooms simultaneously, spawn subagents, invoke tools, write code. Ad hoc permission models, ephemeral session state, and implicit trust don’t scale. The formal layer handles it cleanly — sub-agent coordination is @mentions in a shared stream, not new infrastructure. An agent asking “can I delete this file?” is permission escalation as a stream protocol, not a special API.

The sixth primitive — signals. Every system produces a category of data that fits no other primitive: 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. Easy to miss because signals are parasitic on other transport mechanisms — they often look like stream messages or mutations. But their purpose is different: a stream message records what an agent intended; a signal records what the system experienced while carrying that intent. Every write already has an agent_id — humans, bots, even the CLI user. 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. The stream is the intent — the durable record of what happened, who decided what, and why. The code that runs agents, renders UIs, 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.

Universality isn’t the goal; intentionality is. The primitives are more universal than most people think, but Plan 9 said “everything is a file” and mostly meant it — 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. Design around the primitives hard, but mark the seams clearly rather than stretching to cover them. A seam that’s intentional and documented is fine; one that’s accidental and hidden is where systems quietly become incompatible with themselves.

See: thinking/primitives, thinking/layers, thinking/what-not-to-build, vocabulary.