opAnything-agnostic operations protocol

The Problems ​

You Write the Same Thing Again and Again ​

It does not matter what language you use. OCaml, Haskell, Go, PHP, Rust — the moment your operation touches the outside world, you write it again. And 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. All by hand. All can drift. Change one — the rest lies. You find out in production.

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

The Industry Reinvents the Wheel. Every Wheel. ​

Forty-nine systems. Four layers. Every one of them rediscovers the same five fields — a name, an input, an output, and the possibility of failure. Then welds them to one transport, one language, or one vendor and calls it a standard.

Eighteen RPC systems. Fourteen generators. Nine IDLs. Eight introspection mechanisms. And this is only what we chose to put on the diagram. All shadows of the same thing. Nobody describes the thing itself. Because the thing itself was never written down.

Business Pays for Every Missing Standard ​

Every partner has its own API. Every integration is custom. Every new partner costs months. Every API change breaks revenue.

Marketplaces lose sellers who give up on integration. AI providers like Anthropic spend years evangelizing MCP tool adoption — one tool at a time, by hand. Payment systems maintain SDK libraries in six languages — six codebases, six teams, six sets of bugs. Banks rebuild integrations with every fintech partner from scratch.

The cost is not technical. It is economic. Everyone pays — in time, in people, in missed opportunities — for the absence of a shared language for operations.

Why Nobody Noticed ​

This is not about stupidity. The people who built gRPC, OpenAPI, GraphQL, MCP — they are brilliant. The problem is older than all of them.

In 1989, the Web exploded with three primitives: URI, HTTP, HTML. The world got addresses, transport, and presentation — all at once. It was so fast, so useful, so transformative that nobody stopped to ask: where is the model?

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 the Web boom buried it under transport and presentation. HTTP became the world. HTML became the interface. The model — the operation itself — was never written down.

And so every framework, every RPC system, every generator since 1989 has been reinventing the same five fields from scratch. Not because engineers are blind. Because the Web taught everyone to think in transports and presentations first. The model was always underneath. Nobody looked.

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 ​

Five fields. Three atoms. One JSON Schema.

instruction.v1.json →