The Problems

The Same Thing, Written Many Times

Language does not matter — OCaml, Haskell, Go, PHP, Rust — the moment an operation touches the outside world, the same five fields are written again. A route. A schema. A client. A doc page. A CLI flag. A mock. A test. A metric. An MCP tool. An SDK per language. By hand. The copies drift. One changes — the others quietly lie. The drift surfaces in production.

This is not a tooling problem. This is the absence of a shared source of truth for what code can do.

The Same Wheel, Re-shaped Many Times

Forty-nine systems. Four layers. Each one independently arrives at the same five fields — a name, an input, an output, and the possibility of failure — and carries them along with one transport, one language, one vendor, or one opinion on how granular each operation must be.

Eighteen RPC systems. Fourteen generators. Nine IDLs. Eight introspection mechanisms. And this is only what fit on the diagram. Each one approaches the same form. None of them names the form on its own — because the form on its own had not been a target.

The Cost of a Missing Standard

Each partner publishes its own API. Each integration is written by hand. Each new partner takes months. Each API change ripples through the integrations downstream.

Marketplaces watch sellers drop off when the integration cost is too high. AI providers like Anthropic carry MCP tool adoption forward one tool at a time. Payment systems maintain SDK libraries in six languages — six codebases, six teams. Banks rebuild integrations with every new fintech partner.

The cost is not technical. It is economic. The cost is paid — in time, in people, in opportunities — for the work that a shared primitive would not require.

Why the Form Stayed Hidden

The people who built gRPC, OpenAPI, GraphQL, MCP are brilliant. The form has been older than any of them, and harder to see than it is to use.

In 1989, the Web arrived with three primitives at once: URI, HTTP, HTML. Addresses, transport, presentation — all delivered together. The bundle was so useful and so fast that the model underneath it became part of the background, not part of the question.

Functions had five fields since Fortran in 1957. Syscalls had five fields since Unix in 1971. Every programming language, every CPU instruction set, every network protocol arrived at the same structure independently. The operation was already there — formalized, proven, universal. But after 1989 the line of sight from the model went through HTTP, and through HTML, and the model on its own stopped being a frequent target of inquiry.

Every framework, every RPC system, every generator since 1989 has rediscovered the same five fields. Not because engineers missed something. Because thinking starts with the transport and the presentation when those are the first things you reach for. The model lives underneath. It takes longer to come up.

The Solution

N + M instead of N × M. One instruction format in the middle. New emitter — all receivers for free. New receiver — all emitters for free. The economics of LLVM applied to operations.

Write the operation once. The rest is compiled. Not generated — compiled. With contracts. With guarantees. Like gcc, not like Mustache.

What This Unlocks

Every service describes itself. any://any.com/operations/ — and in the response, everything it can do. A worldwide D-Bus. Not on one machine. On the entire internet.

• Typed clients in any language compile from the instruction. BuyDogInput, BuyDogOutput, BuyDogError = DogNotFound | BudgetExceeded. Exhaustive error matching. Autocomplete. Not written by hand. Not generated from shadows. Compiled from the source of truth.
• Documentation cannot go stale. It is compiled from the same instruction that the code uses. Change the operation — the docs change. Not because someone remembered. Because it is the same object.
• AI agents see every operation of every service. MCP tools, function calling, agent frameworks — all compiled from instructions. One op-receiver-mcp — and every operation in the ecosystem becomes an AI tool. Anthropic gets thousands of tools without evangelizing one by one.
• Monitoring speaks business language. Span names are BuyDog, not POST /api/v2/dogs. Alerts know the dependency graph from the contract. Before the first request.
• Security audits the contract, not the code. Operation DeleteUser has auth: admin but the receiver skips the check? Found before deployment. By a machine. From the instruction.
• Integrations between companies become plug-and-play. New marketplace? Plug in the receiver. New payment provider? Plug in the receiver. No months of custom development. No SDK in six languages. One instruction. Every projection.
• Discovery shifts from content to capability. Today search engines index what you say. Tomorrow they index what you can do. /operations is a sitemap for capabilities. Forgery is impossible: every client call verifies the contract.
• What we cannot imagine yet. Like Mendeleev's periodic table, Op does not need to know what will fill the empty cells. It only needs to guarantee that the structure is correct. The cells are waiting. See: predicted elements.

The developer never sees Op. Like you never see TCP when you open Gmail. The protocol is invisible. Vendors compile from instructions — their reputation depends on the quality. The developer writes business logic. Everything else is compiled.

The Schema

• The Schema Of Instruction — the form of instruction. (WIP)
• The Schema Of Operation — the form of Operation itself.

Forget everything above

Lists. Diagrams. Forty-nine systems. Seven unlocks. All of it true. None of it the point.

Op is not an optimization. Op is a form. Found through long subtractions. Each subtraction made it more applicable. What remained was five fields.

The goal is not to remove boilerplate. The goal is for programs to understand each other's capabilities. The consequences run wider than what we can list today.

If you read this far — you are not a user. You are an early hand. What is below is for those who want to understand.

• The Notes: form of operation — how the form was found.
• The Conjecture — the law that holds it.
• Dream — a book about a world where it worked.
• The Schema Of Instruction — the form of instruction. (WIP)
• The Schema Of Operation — the form of Operation itself.