Essay: Open Standards for AI

We need three standards working together, and we need them to be mandatory.

Right now, there is fragmented work happening across three critical areas: portable user context, intelligent routing across models and providers, and standardised inference APIs. Each piece exists in different states of maturity. None of them are formalised as standards. None of them are mandatory.

They need to be all three.

The problem is fragmentation

Imagine you have built an AI workflow optimised for your needs. You have configured it. You have trained it on your data. You have set your preferences. It works great.

Now try to use that same workflow in a different tool. You cannot. Your context is trapped. Your configuration is trapped. Your preferences are trapped.

This is not a technical limitation. It is a business choice.

Each AI company wants to own your data, your workflow, your context. Lock you in, and you cannot leave. When repricing comes, and it will, you have little options.

That lock in exists because we have not standardised three critical layers.

Open context. Your projects, conversations, preferences, history. Portable. User owned. Switchable between providers.

Open routing. The rules and logic that determine which model, which provider, which inference method to use for each task. Based on capability, cost, your preferences, or the AI's own reasoning about what is best.

Open inference. A standardised API that all models, whether cloud based, local, or anywhere in between, respond to consistently. String in, string out.

Together these three solve the portability problem. Separately, they are incomplete.

Work is underway. It is just fragmented.

There are projects building pieces of this.

Open inference. OpenAI's API format has become a de facto standard. Ollama implements it. Together AI implements it. Hugging Face implements it. The Open Inference Protocol specification exists. But there is no formalised standard body. No mandate. Each company implements their own variation.

Open routing. OpenRouter does this today, routing requests across 400 or more models and providers. Microsoft has model routing in Azure. But again, it is a service, not a standard. The logic and schema are not portable. They are locked to each platform.

Open context. Plurality Network is building an open context layer. There are projects on GitHub exploring portable AI memory. But none of them are standardised. None of them are interoperable. Your ChatGPT export does not seamlessly move to Claude. Your context does not travel between providers.

So here is the situation: the pieces exist. The concepts exist. The demand exists. What does not exist is the unified, formalised, mandatory standard.

What we need

Imagine if web browsers had to implement W3C standards. They do. That is why you can use the same website in Firefox, Chrome, Safari, or Edge. One standard. Multiple implementations.

Imagine if phones had to use USB C. They do now, at least in Europe. One standard. Multiple manufacturers.

That is what we need for AI, through what we are calling Open Standards for AI.

One open context standard. Not proprietary. Not locked to any vendor. A schema that defines how your projects, conversations, preferences, and context are stored and transmitted. Portable. Auditable. User owned.

One open routing standard. A definition of how routing rules work, how they are expressed, how they are evaluated. Whether it is cost based, capability based, user preference based, or LLM decided does not matter. But the standard defines how you express it, and any tool that supports the standard can read it.

One open inference API standard. All models, OpenAI's, Anthropic's, local models, open source models, respond to the same API contract. String in, string out. Consistent endpoints. Consistent parameters. Portable code.

When you have these three standards working together, you can build a workflow once and use it everywhere. You can route requests based on your rules, not the vendor's. You can use the best model for each task. You can keep your data portable and your choices your own.

What this looks like in practice

You are a software engineer working in Cursor or VS Code. You define your routing rules once: major refactoring uses a powerful cloud model, small extractions run locally on your machine, deep analysis routes to the most capable model available.

When you make a request, open routing evaluates it, routes to the right model via the open inference API, pulls your context from open context, executes, and returns the result. All transparent. All defined once. All working across every tool you use.

Or imagine opening ChatGPT and seeing all your projects and conversations. Then closing it, opening Claude, and finding them all there too. One context. One file system. Switchable between providers, just like switching between applications on your computer.

That is what Open Standards for AI enables. That is what we are pushing for.

The credibility is there

This is not theoretical. The work is happening.

Open inference is converging on a standard. The market has largely chosen OpenAI's API format because it works. Ollama chose it. Together AI chose it. The Open Inference Protocol specification exists. The direction is clear.

Open routing works today. OpenRouter proves the concept. Auto routing based on cost and quality is possible. Model selection is possible. Provider selection is possible.

Open context is being built. Plurality Network. Multiple GitHub projects. The technical challenges are understood. What is missing is coordination and mandate.

The ask is not to invent something new. It is to formalise what is working, integrate the pieces, and make it mandatory.

What Present Thread is pushing for

We are advocating for open context, open routing, and open inference to be formalised as standards, integrated as a coherent layer under the umbrella of Open Standards for AI, and made mandatory for AI companies operating in regulated markets.

Not because these ideas are new. Because the work is fragmented and needs coordination.

Not because it is charity. Because open standards are how industries mature, competition works, and innovation accelerates.

Not because it is optional. Because the alternative, proprietary lock in by a handful of companies, is unsustainable and unfair.

The W3C did not invent the web. They standardised it. That is what needs to happen here.

The timeline

This will not happen by accident. It will require regulatory pressure. The EU has the track record: browser standards, USB C on iPhone 15, GDPR. They understand how to mandate interoperability.

It will probably take a correction. Repricing. Some company failures. Market pressure. And then the EU will do what it has already done before: step in and force the dominant players to open up.

When that happens, everything changes. You are no longer a pawn in someone else's game. You are a participant with choices.

The third essay in this series explores why that is probably exactly what is going to happen, and when.

This is the second essay in a series. "The Kobe Problem" explores repricing. The third essay explores why we have solved this before and why we are probably going to have to solve it again.