OpenNodes — the discovery layer for AI inference

The loop

Discover → verify → estimate → invoke → receipt

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.

Why it's different

Verified, not just ranked

Anyone can list. No one is trusted blindly.

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

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.

Quickstart

Three ways in

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

The registry app — browse, rank, register

Every registry serves an OpenRouter-style web app at its root: searchable catalog with transparent per-result rank explanations, node pages with probe and listing history, and the full registration + qualification flow (submit card → namespace challenge → Stage A → Stage B). The hosted instance is live at registry.opennodes.io — 9,000+ offerings across registered nodes and the OpenRouter, Hugging Face, models.dev, and Ollama catalogs, re-imported every six hours. Or run your own (Node ≥ 22.5):

npx @opennodes/registry                      # app + API + MCP on http://127.0.0.1:4300

OpenNodes for Ollama — local, LAN, and verified cloud behind one endpoint

One Ollama-compatible endpoint: your local models, your other machines (plain Ollama or Node Kit nodes, found via mDNS), and verified public nodes with pinned prices and signed receipts. auto-private never leaves your network. Works unchanged with Open WebUI, Continue, Zed, Msty, and the ollama CLI.

npx @opennodes/ollama-router                 # then OLLAMA_HOST=127.0.0.1:11435
ollama run auto-private "summarize this confidential note"   # routes only to local / LAN models

Model search, the advisor & chain pricing inside your editor (MCP)

npx @opennodes/cli mcp --print-config        # paste into Cursor / VS Code / Claude Desktop

Any OpenAI-compatible app, routed through discovery (gateway)

npx @opennodes/cli gateway --port 4141       # models onp/auto, onp/auto-cheap, onp/auto-private, …
# point the app's OpenAI base URL at http://127.0.0.1:4141/v1

Serve your own model as a node (Python kit, engine 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
onp-node serve && onp-node check && onp-node register https://registry.example.org

A desktop client that speaks both layers (Surge)

Surge (pre-release: Windows installer, source on GitHub) is a desktop "browser for MCP" and the reference OpenNodes client. The model picker is fed live from an ONP registry — trust tier, measured latency, per-MTok price — and Auto runs the advisor on your machine to pick a node per prompt. Every call goes direct to the node, pinned to its card revision, and comes back with a signed receipt that Surge verifies (amount = usage × pinned price) and shows under the reply. A spend policy is on from first launch (spending off until you set a budget), a dashboard keeps the ledger, and one click switches to private mode: your local Ollama and LAN machines only. Models via OpenNodes, tools via MCP, in one app.

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.

The discovery layer for AI inference