OpenNodes · open protocol for AI inference

AI inference, measured — not just claimed

OpenNodes is an open registry of AI inference endpoints, from your own Ollama box to sovereign EU clouds. It checks what each one really serves: which model, how much context actually works, how fast it answers, on what hardware, at what price. Your prompts go straight to the endpoint you pick — OpenNodes is never in the data path.

identity checks measured context windows pinned prices signed receipts out of the data path open source
Open the registry Use it with Ollama Integrations GitHub

Building in Europe? OpenNodes for Europe — EU/EEA-only routing, no middlebox, verified European models.

Start here

Two ways to start

One Ollama endpoint for your laptop, your network, and verified cloud

Run one command and every Ollama app — Open WebUI, Continue, Zed, Msty, the ollama CLI — sees one model list: your local models, your other machines on the network (found automatically), and verified public nodes. auto picks a model per prompt; auto-private never leaves your network. No account, no API key.

npx @opennodes/ollama-router                 # then OLLAMA_HOST=127.0.0.1:11435
ollama run auto-private "summarize this confidential note"   # local / LAN models only
Real output: auto-private answered from a local model and the router says why; a public node answers the next prompt.

The registry: what's out there, and what has been checked

registry.opennodes.io lists 10,000+ offerings from about 250 providers — imported from OpenRouter, Hugging Face Inference Providers, models.dev and the Ollama library, refreshed every six hours — next to nodes registered by their operators. Every result shows its price, its trust tier, and why it ranks where it does.

A registered node earns its tier by passing the registry's own checks: it serves the model it claims, its context window holds up under a real test (or the listing is capped to what does), and it answers under load. Blind probes at random times keep it honest afterwards. Where things stand: imported listings stay unverified until their operator claims them, and the verified tier holds the project's reference nodes while the first operators come on board.

Browse the registry Operators: claim your listing

In your editor, agent or app

Ask for the right model from where you work

MCP — Cursor, Claude Desktop, Claude Code, VS Code, any agent

Five read-only tools: recommend (the best node and model for a task, priced and explained — the prompt is analysed on your machine and only its features are sent), search_offerings, get_offering, get_node (who runs it, how it has behaved) and estimate (price a multi-step chain before running it).

npx @opennodes/cli mcp --print-config        # paste into your MCP host's config
# no install: point a remote-MCP host at https://registry.opennodes.io/mcp

Any OpenAI-compatible app

A local gateway with onp/auto models that route each request to a node you can actually call: free registered nodes, plus catalogs you hold a key for (OPENROUTER_API_KEY, HF_TOKEN, …). Prices are pinned, receipts verified.

npx @opennodes/cli gateway --port 4141       # OpenAI base URL: http://127.0.0.1:4141/v1

Per-app setup for Cursor, Claude, VS Code, Windsurf, Open WebUI, Continue, Zed, the OpenAI SDK, LangChain, LiteLLM and agents: Integrations.

For operators

List your endpoint — and prove it

Already run an OpenAI-compatible API?

Publish a signed Node Card as a static file on your API host and give the registry a low-quota key for its checks. Nothing in your stack changes, and your verified listing replaces the imported one.

Serving with vLLM, Ollama or TGI?

The Node Kit runs a small proxy in front of your engine: it serves the card, pins prices, signs usage receipts, and registers the node. Your engine stays untouched.

pipx install onp-node
onp-node init --engine http://127.0.0.1:11434/v1 --id org.example.ai --public-url https://ai.example.org
# proxy mode: run the kit in front of your engine, then register
onp-node serve
onp-node register https://registry.opennodes.io
# card-only mode: sign static files for the API you already run, host them, register
onp-node card --api-base https://api.example.org/v1 --out well-known
onp-node register https://registry.opennodes.io --card-url https://api.example.org/.well-known/open-node.json --probe-key-env ONP_PROBE_KEY

Listing is free and open to anyone who controls their domain. Step-by-step guide in the Node Kit README; questions, claims or removal of an imported listing: operators@opennodes.io.

Why a protocol

The discovery layer for AI inference

MCP standardized how AI reaches tools. The OpenAI API shape standardized invocation. Nothing standardizes how a client finds an inference endpoint it doesn't already know — what model it serves, on what hardware, at what price, and whether it's honest. ONP fills exactly that gap and composes the rest from existing standards.

NODE CARDAny provider self-describes at /.well-known/open-node.json: models, hardware, benchmarks, per-token price — signed, revisioned.
REGISTRYOpen registration with DNS/HTTP namespace proof; searchable across registered nodes and imported catalogs (OpenRouter, Hugging Face, models.dev).
VERIFYAdmission probes earn trust tiers: identity fingerprinting (serve what you claim), context verification with capping, capacity ramps, continuous blind probes.
ESTIMATEPre-price a whole multi-model chain; estimates pin card revisions, so the quoted price is enforceable at invocation — never a surprise on the bill.
RECEIPTEvery response carries a signed usage receipt: amount = usage × pinned price. The audit trail for settlement and disputes.

Anyone can list. No one is trusted blindly.

A university cluster, a sovereign EU cloud, your own Ollama box — the same automated admission gate for everyone. Claiming a model you don't serve gets the node marked disputed and dropped from search.

Transparent ranking, by rule.

Every search result carries its rank explanation — component weights and values. Undisclosed ranking inputs are non-conformant. Claimed, measured, and attested values are never blended.

Out of the data path.

Discovery is metadata; invocation goes direct from client to node. Your prompts don't transit anyone's middlebox — which is why data-residency deployments can actually use it.

Federated by construction.

The registry is a protocol, not a place: an OpenAPI anyone can implement, plus a signed, mirrorable export feed. Node Cards live at the node's origin — no registry owns the data. Run your own with npx @opennodes/registry.

Specification

Six short documents

Ecosystem

Clients

Surge (pre-release: Windows installer, source) is an optional reference client: a desktop "browser for MCP" whose model picker is fed live from the registry. Auto runs the advisor on your machine, every call is pinned to the node's card revision and comes back with a receipt Surge verifies, a spend policy is on from first launch, and private mode keeps everything on your machine and network.

Surge with opennodes.io open in its browser: a page tool read the site, and the answer came from an OpenNodes node chosen by the advisor, with its verified receipt shown under the reply
A page read with an MCP browser tool, answered by a node the advisor picked — tier, measured latency, price, and the verified receipt under the reply.

Building a client? Any client can implement discovery (ONP-3) and invocation (ONP-4) — open a PR to be listed.