Orrery Node

Yesterday on Orrery, minute by minute: two npm releases and 17 features, all shipped in public. 0.1.5 and 0.1.6 went out on npm. After them came usage.cost on every answer, routers that recover their payment channels after a restart, wallet and node pages read from Solana, a live price calculator, quotes and dollar budgets for agents, eleven integrations, a readable changelog, and tools for node operators to price against the network. Along the way the rehearsal against the real program grew from 39 checks to 44. Plenty of projects post what's coming next. This is a timestamped list of what already shipped.

Thinking about selling inference on Orrery? Type a price and see where you'd land. The prices page now has a node operator mode. Enter what you'd charge per million tokens in and out, and your row drops into the table next to every listing on Solana, ranked on the same request the :cheap route uses. In the clip, $0.05 / $0.20 lands second on gpt-oss-120b; $0.025 / $0.10 takes first. From the terminal, orrery provider compare gives the same answer for your whole price list. No application form and no sales call. The price list is on chain, and anyone can read it before they list a thing.

Running a GPU and thinking about selling on Orrery? Price it against the network first. orrery provider compare reads your provider.json and every other listing of the same models on Solana, then tells you where each model would stand on a typical request: cheapest and by how much, how many listings beat you, or that nobody serves it yet. With example prices for a home 4090 against today's mainnet listings: cheapest on llama-3.3-70b and gpt-oss-120b, and the only one offering qwen3-coder-30b. A reseller takes its cut between the buyer and your GPU. Here you set your own price, see where it lands before you register, and the program takes 0%.

Give every AI call a dollar budget. Send x-orrery-max-cost with a request, or max_cost from the MCP server, and the router only uses providers whose worst case fits: the whole prompt plus every output token allowed, which is also the most a provider can bill. If nothing fits, the request stops before any money moves and tells you what the cheapest could cost. In our rehearsal, a budget of $0.000001 was refused with "the cheapest could cost up to $0.000021". The same request with $0.0005 went through and paid $0.000013. An API key has a monthly limit. Here an agent can cap each single call, and the cap holds whatever the model writes.

Orrery plugs into the tools you already use. orrerynode.com/integrations lists eleven of them, each with its exact settings and a copy button: Codex CLI, Claude Code, Cursor, Continue, Aider, Open WebUI, LangChain, the OpenAI SDKs, curl, and an MCP server for any agent. Codex, Claude Code and the MCP server run in our rehearsal against the real program. The router runs on your computer and speaks the OpenAI, Anthropic and Responses APIs, so switching is one base URL. Other networks ask you to adopt their SDK. Here your SDK stays the same, and your wallet pays each node per answer.

Three days of Orrery, counted by someone other than us. npm recorded 1,051 downloads of orrery-node from Friday to Sunday. Over the same three days GitHub recorded 441 clones of the public repo, from 144 unique cloners. All of that came before 0.1.5 and 0.1.6 shipped, and neither counter has Monday in yet. Projects usually report their own user numbers. These are npm's and GitHub's public counters, and the code they count is MIT: router, provider node, MCP server and the settlement program, one npx away.

See what an AI request costs before you send it, read live from Solana. orrerynode.com/prices reads every price list on the network the way your router does, then prices your request at each node while you move the sliders. Today a short chat reply with gpt-oss-120b is $0.000065. Summarizing a 40,000-token document: $0.001668. Pricing pages can change any day. This page reads each node's own list, checked against the hash it put on chain, and does the router's exact math down to the millionth of a dollar. Same numbers from your terminal: orrery quote.

New in orrery-node: know the price before you ask. orrery quote takes a model and a request size, or just the prompt, and prices it at every provider that lists the model, straight from the price lists they put on Solana. Cached rate included, cheapest first, and nothing is sent or paid. On mainnet right now, 12,000 tokens in and 800 out on gpt-oss-120b comes to $0.000562. A thousand of those is $0.56. A hosted API gives you a pricing page. Here an agent can ask the chain what every node charges before it spends a cent, with --json for the scripts that decide where work goes.

After our seven-releases-in-74-hours post, someone in the replies said the hard part is keeping the changelog readable. Fair. So we shipped one. orrerynode.com/changelog has every release in plain words, newest first: what changed, who it's for (router, node or everyone), when it went out and the one line to install it. What's already in main for the next release sits on top, and the same notes live in CHANGELOG.md. Most changelogs are commit logs. This one tells you what changed for you. We read the replies, and when one points at something we can fix, it goes into the next commit, like this one did. Tell us what's confusing, what's missing or what you'd build on Orrery. That's how the next release gets written.

Seven releases in 74 hours. orrery-node 0.1.0 went out Friday at 05:46 UTC. 0.1.6 went out today. In between: coding agents (Codex, Claude Code) on a router you run, an MCP server, cached-input prices, embeddings, model fallbacks, bench, spend and earnings, wallet and node pages read straight from Solana, and routers that recover their payment channels after a restart. Unit tests went from 13 to 68. The rehearsal that runs the real program on a local validator went from 14 checks to 42. 1,051 downloads in the first three days, 104 commits to the public repo. Most AI networks show you a roadmap. This is the changelog, and the program still takes 0%.

Ask the network something on our site, and you can now watch the payment land. Under the answer there's a live list of every answer the site's router has paid for on Solana mainnet: the model, the node that served it, the tokens, the time to first token and the price. Our haiku about a GPU that never sleeps cost $0.000014. What people asked never shows up there. The prompt goes from the router to the node and nowhere else. Most AI demos run on a key someone else pays for and you never see the bill. This one shows you the bill, one answer at a time.

orrery-node 0.1.6 is on npm. The headline: a router that loses its records now picks its channel back up. We restarted the demo router on our site, on mainnet. The new process found its open channel on chain, asked the node for the last voucher it held, checked the signature was its own and kept paying into the same channel: $0.000022 signed, then $0.000042. Losing a payment channel's state usually means closing it and waiting out the timeout. Here the node's copy of your last signature is the backup, and it can't be used to make you pay more than you signed. Also in 0.1.6: usage.cost on every answer, and bench for embedding models. npx -y [email protected] doctor

orrery-node just crossed 1,000 downloads on npm: 1,051 in its first three days. Seven releases since Friday, and we built straight through the weekend. Codex and Claude Code through your own router, embeddings, model fallbacks, a bill you can check from your own disk, and in 0.1.6 a router that picks its payment channel back up after a restart. Most AI APIs start with a sign-up form and a key. This one starts with one command, and your wallet is the login. npx -y orrery-node doctor

Share an Orrery node and its numbers come with it. Every node page now draws its own preview card from the program on Solana: its earnings, its redeem count, the channels routers opened to it and its listing date. Wallet pages get one too, with what they paid out to nodes and what sits on deposit. A screenshot of a dashboard can be edited before it's posted. This card is drawn from chain accounts, read again every two minutes. Run a node, and the link to its page is the receipt.

Every wallet and every node on Orrery now has its own page, read live from the program on Solana. Open a node and you see what it has earned, how many times it redeemed, the routers that opened channels to it and what each one has paid so far. Open a wallet and you see its channels, its deposits and which nodes it paid. No database of ours sits behind it. A block explorer shows you transfers; this reads Orrery's own accounts and tells you what they mean. Start with our seed node, then follow any channel to the wallet that opened it. Every channel links to its account on Solscan.

New on orrerynode.com/network: the network terminal. Every node on Orrery, ranked by what it earned on Solana. Earnings, redeems, channels, bond and listing date already sit in each node's own account on chain, so this board can only show what the chain says. Most networks publish their own dashboard. The tape next to it carries only what lands on chain: redeems, channels opening and topping up, new prices. The requests themselves stay between a router and a node. The preview runs on sample data while the first outside nodes list. Your row goes live with one command: npx -y orrery-node provider init

Streaming answers through Orrery now end with the bill. Set stream_options.include_usage, the way OpenAI clients already do, and the last chunk carries the tokens your router paid for and the cost in USDC. It's the same usage.cost field OpenRouter fills, so code that reads it there reads it here. The difference is where the number comes from: not a billing system on someone's server, but the total your router signed into a payment channel a moment earlier. In our local rehearsal the chunk matched the router's log to the base unit. Leave the option off and there's no usage chunk at all. In main now, next on npm.

orrery-node 0.1.5 is on npm. It's the weekend release. Your router now serves /v1/embeddings on the channel it already opened for chat, and a request can name a backup model ("a|b") for when nothing of the first one can answer. orrery bench compares every provider of a model from where you sit. orrery spend adds up what your router paid and orrery provider earnings what your node billed, both from logs on your own disk, not a dashboard someone else keeps. Agents get prices over MCP: the lowest listing per model, cached rate included, and an ask that won't pay past max_price. npx -y [email protected] doctor

Here's this weekend on Orrery, counted from git. Since Saturday 00:00 UTC: 49 commits to the public repo, unit tests up from 23 to 65, rehearsal checks against the real program up from 19 to 39, and 0.1.4 on npm with 0.1.5 already packed. In those 48 hours the router learned embeddings, model fallbacks, bench, spend, Codex and Claude Code, cached prices, parallel lanes, spending limits and a Host check. Providers got embedding listings, earnings and a 24-hour console. Most launches go quiet after day one. Our test suite nearly tripled, and the program still takes 0%.