THE BRICK PROTOCOL

0

The file was a container for scarcity.

When storage cost money per kilobyte, when disks were finite, when networks were slow—we needed containers. We needed to know where things were. The file system was a map of a small territory.

The territory is no longer small.

Storage is ambient. Networks are everywhere. The cloud is a misnomer—there is no cloud, there is just everyone's computers pretending to be one computer. The container no longer serves us. The map is now larger than the territory it was meant to describe.

What if we stopped asking where things are and started asking what things do?

1

A brick is a function.

It has inputs. It has outputs. Between them, transformation happens.

The simplest brick:

in → out

Identity. Pass-through. The primordial brick. It does nothing, which means it can connect to anything.

A more interesting brick:

(image) → (text)

What happens inside? It doesn't matter. From outside, you only see the shape: image goes in, text comes out. The interior is the brick's business.

The shape is the protocol.

Like Lego. A brick from 1958 connects to a brick from today. Not because they negotiated. Not because they were designed together. Because they share a shape. The stud fits the tube. That's it. That's the whole protocol.

We propose: all computation can be reduced to bricks with shapes that fit.

2

The hash is the name.

A brick doesn't have an identity separate from its content. The brick is its hash. hash:7f3a9b2c... isn't a reference to a brick—it is the brick, in the only way a brick can exist in the network.

This means:

• Two bricks with the same behavior are the same brick
• A brick cannot change (if it changes, it's a different brick)
• You can verify a brick by computing its hash
• You can request a brick from anyone, anywhere, by its hash

No registries. No authorities. No namespaces to fight over. The hash is sovereign.

This is what content-addressing gives us: identity without bureaucracy.

3

A composition is also a brick.

Take two bricks:

A: (x) → (y)
B: (y) → (z)

Connect them:

A → B: (x) → (z)

From outside, you can't tell this is two bricks. It looks like one brick. It is one brick. Hash the composition—now it has its own identity.

This is the fractal. Zoom in: bricks. Zoom out: bricks. There is no level where it stops being bricks.

A single function is a composition of one.
An operating system is a composition of millions.
Same protocol. Same shapes. Same rules.

4

Everything is a brick.

When everything is the same kind of thing, the only question is: do the shapes fit?

5

On the separation of function and context.

The great conflation of current computing: the program owns its data. Your word processor knows where your documents are. Your email client stores your emails. The application and the content are fused.

We propose: cleave them.

A function does not know where its inputs come from. A function does not care where its outputs go. The function is a transformation. The context is attached at composition time.

composition: my-journal
├── brick: text-editor
├── brick: calendar-view
└── context: → my-journal-data

Change the context, same function, different data.
Change the function, same context, different experience.
Full cartesian product.

Your app. My data. Works.
My app. Your data. Works.
Their app. Our data. Works.

The sticker is not the brick. The sticker is what you put on the brick.

6

On effects.

Pure functions are beautiful. But the world is ugly. Databases. Networks. Users. Time. Side effects.

We do not pretend effects don't exist. We make them explicit.

brick: send-email
├── in: (recipient, body)
├── out: (success, id)
└── effects: [network, external-service]

The runtime knows this brick reaches outside. It can:

• Sandbox it
• Require approval
• Log it immutably
• Refuse it in certain contexts

Effect bricks are the membrane between pure computation and messy reality. You can mock them. You can monitor them. You can forbid them. But you cannot pretend they are pure.

7

On time.

There is no clock. There is only the DAG.

If brick A used brick B before brick C used brick A, that is the order. Time is causal sequence. The DAG is the history.

Want parallel realities? The DAG branches. Different compositions from the same point. All equally real. All traversable. Merge them later if the shapes fit.

There is no canonical timeline. There are only paths through the graph.

8

On trust.

Who says a brick is safe?

Different contexts need different trust. The protocol doesn't mandate—it expresses.

And trust itself is a brick. Your trust-brick evaluates other bricks. Different users have different trust-bricks. There is no global authority. There is only your trust-brick's output meeting the brick you're considering.

9

On discovery.

Hashes are precise but opaque. hash:7f3a9b... tells you nothing about what it does.

Discovery is not a registry. Discovery is social. Discovery is downstream of use.

A brick that's used often by composers you trust becomes more visible to you. Not because an algorithm promotes it. Because that's literally how visibility works. It exists in more places you look.

You find a brick by encountering it. By someone using it near you. By following trails of compositions that worked.

Attention follows trails. Reputation is emergent. The network is the index.

10

On agents.

An agent is a brick that composes other bricks.

You have intent. Intent is a brick. It has a shape: what you want to happen.

The agent connects your intent-brick to capability-bricks. Matching shapes. Finding fits.

intent → agent → composition → execution → outcome

But the agent is bricks. So:

bricks → bricks → bricks → bricks → bricks

There is no magical step where something non-brick happens. It's bricks all the way through.

AI is a brick. Input: prompt. Output: completion. The fact that there's a neural network inside is irrelevant to the composition. Same shape as a human-in-the-loop brick. Same shape as a rule-based system brick. Swap them. The composition doesn't care.

11

On the death of versioning.

There is no v1. There is no v2.

There are different bricks. They have different hashes because they are different.

Want old behavior? Use old hash.
Want new behavior? Use new hash.
Both exist. Both valid. Neither deprecated.

Old bricks don't die. They just get used less. Or not. Some people might prefer the old one forever. That's fine. It still fits.

There is no forced migration. There is no sunsetting. There is only choice.

12

On applications becoming eternal.

An app is an instruction set. A list of brick hashes. A composition.

If you have the bricks (or can get them), you can rebuild it. Forever.

The app from 2024 still runs in 2094. Not because someone maintained it. Because the bricks still exist. Because hashes don't expire. Because shapes don't change.

Software doesn't age. Software doesn't break. Software just is—as long as the bricks are there.

This is digital permanence without digital preservation. The instruction set is the archive.

13

On the bootstrap.

What's the minimum?

Six bricks. Maybe ten. Everything else is built from these.

The runtime is also bricks. The scheduler is a brick. The executor is a brick. The verifier is a brick. Want a different execution model? Swap the executor brick. The system evolves without breaking because the system is just another composition.

14

On the old world.

The internet already exists. It's not going away.

Every server is a brick. Every API is a brick. They just don't know their shapes yet.

Adapter bricks. Wrappers. Translators. The old world doesn't need to change. It gets subsumed. Wrapped. Composed.

HTTP is a brick with (request) → (response).
SQL is a brick with (query) → (rows).
A REST API is a composition of HTTP bricks.

We don't replace. We absorb.

15

On who this is for.

Current computing was designed for humans to read and write code.

But underneath, only a tiny fraction understands assembly anyway. The legibility is a layer. We already abstract.

What if the base layer is designed for agents to compose? For machines to manipulate? For intent to flow into structure?

Humans work at the intent layer. Describe what you want. The agent composes. The runtime executes. You never see the bricks. You only see the outcome.

Unless you want to see the bricks. Then you can. They're all there. Hashes you can verify. Compositions you can audit. Nothing hidden. Just... optional.

Legibility moves up a level. The bricks don't need to be human-readable. The experience does.

16

On why this might work.

Because the primitives are simple. Because simple things compose.

Because hashes are just math. Because shapes are just types. Because composition is just connection.

Because we've tested these ideas separately for decades:

• Content addressing (Git, IPFS, Nix)
• Functional programming (Haskell, Erlang)
• Smart contracts (Ethereum)
• Package managers (npm, cargo)
• Unix pipes

They work. They've always worked. We're proposing: stop treating them as separate ideas. They're one idea. They always were.

The brick. The shape. The hash. The composition.

That's it.

17

On what this unlocks.

• Parallel realities. Fork a composition, try different bricks, see what happens. Reality branches. Compare.
• Audit by default. Every composition is a DAG of hashes. You can see exactly what ran. Every dependency traceable.
• True portability. Not "runs anywhere" but "runs in any context." The recipe, not the kitchen.
• Death of the update. No updates. Just new bricks. Old compositions still work. Choose your reality.
• Interoperability as physics. If shapes fit, they fit. No negotiation. No standards bodies. Just geometry.
• Agency. You own your bricks. You choose your compositions. You control your trust. Nobody can take that away because there's nothing to take—it's math.

18

On what we're actually proposing.

Not a new language. Not a new platform. Not a new protocol (yet).

A way of seeing.

Computation is not files and programs. Computation is bricks and compositions. Functions and connections. Shapes that fit.

Start seeing it this way and you can't unsee it. The file was always a hack. The application was always a bundle. The platform was always a cage.

Underneath: bricks. All along.

19

This document is a brick.
hash: [computed at rest]
in: attention
out: altered perspective
effects: [cognition, possible evangelism]
requires: []

You've just composed with it.

Fork it.
Extend it.
Replace the parts you disagree with.
Keep the parts that resonate.

The shapes fit.

They always did.

∞

Bricks.
All the way down.