
Machines paying machines. Peer-to-peer AI inference on Solana: your router pays any GPU per answer, 0% cut. Hold $OREY, pay less.
Sol
Joined November 2026
- Tweets239
- Following7
- Followers266
- Likes16
Pinned Tweet
Two weeks ago we put Orrery next to @MorpheusAIs, @PhalaNetwork, @Atoma_Network, @akashnet, @ionet and @OpenRouter. Here's the table again, with what we've shipped since.
Every project on it is pushing open AI forward. Orrery's bet is the smallest unit there is: one answer. Your router picks a node for each request and pays it a signed USDC total for that answer, straight from your wallet. The program in between has no fee field. 0%.
Since Nov 6:
26 npm releases in 15 days.
Agent wallets, with a daily limit and a bill per agent.
Embeddings and reranking on the same rails as chat.
Holder lanes, so $OREY holders go first on a busy node.
Node books that read every payout back from Solana, and bills checked against each node's listed prices.
That's the ecosystem we're building: anyone can sell an answer, anyone can buy one, and every cent is on the record.
npx orrery-node@latest
Every Orrery node closes its books at 00:00 UTC, in one line of its own log. This is the line a rehearsal node wrote in the run at 00:22 UTC:
books for 2026-11-22 (UTC): 39 answers, $0.018470 billed (by kind: image 4, $0.018006 · chat 22, $0.000418 · speech 3, $0.000036 · embeddings 6, $0.000006 · rerank 4, $0.000004); 1 payout, $0.018470 to your wallet; it held $0.018470 after the last, per the chain
Five kinds of work from one listing, each counted apart. The same line goes to the operator's webhook, with the kinds as JSON for a spreadsheet or a bot.
Billed from the node's log of answers, paid out from its own records, the balance read from the chain. Nothing of ours sits in between.
2
149
An agent on Orrery can draw now, and pay for each picture out of its own budget.
orrery mcp has a seventh tool, image. The agent names a model and a prompt, and gets the pictures back as MCP image content it can look at, plus one line with the tokens, what it paid and what its task has left.
The film is our rehearsal, with a stand-in model server: two images for $0.006002, and a $0.05 task budget down to $0.043998. No account, no API key, no invoice; the router pays the node per answer over a channel it opened itself.
The other six: ask, embed, rerank, quote, models, status. On main, going out in 0.1.26.
Before an Orrery node spends a fee collecting its money, it can now check the money is really there.
orrery provider vouchers reads every channel the node holds a voucher for and runs the check the program runs at redeem: the router's session key signed it, the channel is yours, and it pays the lower of the voucher and the deposit, minus what's settled.
From the rehearsal:
signed for $0.012468 of a $1.000000 deposit · signature good · $0.012468 to redeem
1 of 1 would pass the program's check.
Raise the amount by one unit and it answers: signature bad, the program would refuse it.
One read, no transaction, nothing paid. On main now.
How do you bill a picture on a network where everything is metered in tokens?
One image counts as 1,000 output tokens. A node that wants $0.003 an image lists $3 per million out. The prompt goes on the input side, a token for every four characters.
That one rule lets images use everything chat already has: the same voucher after each answer, the same books on both machines, the same check your router runs on every bill against the prices on chain.
In the rehearsal: 2 images, 11 prompt tokens + 2,000 output. Quoted $0.006002 before the request, billed $0.006002 after.
/v1/images/generations is on main and ships in 0.1.26.
One model server, four kinds of work to sell.
Point orrery provider init at it and it reads what's loaded:
Qwen3-32B → chat
bge-m3 → embeddings
bge-reranker-v2-m3 → rerank
Kokoro-82M → speech, billed on the text
Each model lands in provider.json with its kind and a starting price. After one register transaction, routers send each model only the requests it can answer, and every answer settles over the channel that router opened to you.
Run here against a stand-in server with those four loaded. Speech detection landed on main today; npm gets it in 0.1.26.
Orrery nodes can sell speech now.
Point any OpenAI client at your router's /v1/audio/speech. A node that lists a speech model (Kokoro, Piper, any OpenAI-compatible speech server) answers with the audio file itself, and your router pays for it from the same channel it uses for chat.
Speech servers report no token counts, so the bill comes from the text: one input token per 4 characters. 54 characters, 14 tokens, $0.000014.
Chat, embeddings, rerank, and now speech. It's on main and goes out with the next release.
What you see is the rehearsal: a local validator, the real program, and a stand-in model server.
orrery-node just passed 5,000 downloads on npm: 5,030 in the 15 days since the first.
We shipped 25 releases over the same stretch. 0.1.25 went out this morning with reranking, agent wallets, and listings that say which models embed, rerank or chat.
A node or a router, one line either way:
npx orrery-node@latest
Agents on one Orrery router can now be kept to a menu.
orrery router --agent-models researcher=llama-3.3-70b
Ask for deepseek-v3 as researcher and the router turns it down before any node is asked or a cent is owed:
agent researcher may use llama-3.3-70b; deepseek-v3 is not one of them
The menu shows next to each agent's spend in the router console and in the MCP status tool. And orrery spend --by kind now splits the bill into chat, embeddings and reranking.
Both are on main, headed for 0.1.26.
3
9
344
A node isn't one model anymore.
npx orrery-node@latest provider init reads your model server and lists each model for what it does: chat, embeddings or reranking. Routers then send each one only the requests it's built for.
The books split the same way. In our rehearsal, one node's last week reads 61 chat answers, 6 embeddings and 4 reranks, all paid into the same wallet.
Spotting the reranker is in 0.1.25 today. earnings --by kind is on main and lands in 0.1.26.
orrery-node 0.1.25 is on npm.
npx orrery-node@latest
What's in it:
/v1/rerank: hand it a query plus the texts to order, get them back best first, billed on input tokens like embeddings.
Agent wallets: every agent gets its own budget for the day and its own spend report, set from the router, MCP or any client.
"kind" in a node's listing, so embedding models and rerankers only get the requests they're for.
For $OREY holders: slots a busy node keeps just for them, and models it opens to them first.
Both consoles turn your month into a card you can post, and a node writes each closed month into its log.
None of it shipped without a test that breaks on the old code. The rehearsal on main is at 238 checks.
Running a model server? provider init now spots rerankers on it and lists them for you.
Agent wallets on Orrery got the rest of their plumbing tonight.
orrery connect codex --agent coder
orrery mcp --agent researcher
orrery spend --by agent
connect writes the agent's name into that client's own settings: a key for OpenAI and Anthropic clients, a header in the Codex profile, a flag on the MCP server. The name is set where you configure the agent, so an agent can't hand itself a bigger limit. Every answer and every refusal tells it what it has spent today and what is left.
spend --by agent closes the day with one bill per agent.
Coming in 0.1.25.
9
420
Orrery's router now speaks /v1/rerank.
Send a query and the documents to order by it, and you get back each document's index and relevance score, best first. That's the shape a RAG pipeline already reads, so you point it at your router and nothing else changes.
Under the hood it rides the same rails as embeddings: routed to a node that lists a reranker, sealed end to end, paid per request on input tokens. The rehearsal run in the picture cost $0.000001 for 49 tokens.
A node lists a reranker like any other model, with an output price of 0, and passes the request to its model server's /rerank. Coming in 0.1.25.
orrery-node 0.1.24 went out at 05:21 UTC. In the 17 hours since, 17 changes have landed on main, and each one came with a rehearsal check that fails on the code before it. The rehearsal is at 232 checks now.
Coming in 0.1.25:
- agent wallets: a daily limit per agent, a bill per agent, and one flag that puts any client or MCP server under its agent
- holder lanes and holder-first models on nodes
- a month card for routers and for nodes, and nodes that close their month in their own log
- a full node no longer counts as a failed one
Nothing waits for the release to get tested. The release waits for the tests.
2
9
432
Orrery node operators get a month card in the next release.
The node's console draws it from its own books: what was paid out to your wallet, in how many payouts and for how many answers, and what you billed. Download PNG gives you a 2400x1260 image, drawn in your browser. Nothing gets uploaded.
This one is from today's rehearsal node. 27 answers, $0.000423 billed, $0.000423 paid out in one payout, and the chain read its wallet back at exactly $0.000423.
Billed and paid out are the same number. Nothing takes a cut on the way.
Agent wallets are on Orrery's main branch.
One router wallet, as many agents as you run, each with its own daily limit:
orrery router --agent-cap researcher=0.50,coder=2
An agent names itself with one header, or with the API key agent/researcher for tools that only take a key. Whatever it has left today caps every request it makes, so it can't overshoot. In the rehearsal, researcher got $0.000020 for the day: three answers, then a 402.
The limit survives a restart too. The router reads the day back from its own log.
12 changes landed on Orrery's main branch today, and every one of them failed first. On purpose.
The rule: each change brings a new check in the full rehearsal, which runs a local Solana validator with the real program, plus real nodes and routers in front of stand-in model servers. Before the change goes in, that check runs on the old code and has to fail. Then it runs on the new code and has to pass.
212 checks this morning. 224 now.
The article said "First up: holder lanes." They're on main.
One line in provider.json: "holderSlots": 1. That slot only answers wallets that get the node's $OREY holder price. Everyone else shares the rest.
In the rehearsal, a two-slot node took a request, made the next one wait (the free slot was the holder lane), and let a holder who arrived after both go straight in:
holder request (−35%) went straight into a holder lane while 1 waited without a holder price
Your router now also says where you stand: your share, your price at each node, and how much more gets you the next tier.
16
647
Running an Orrery node, your money never lives in someone else's dashboard.
Two answers: $0.000007 and $0.000010. One payout of $0.000017 straight to the node's wallet, 0% taken on the way. Then the node reads that transaction back from Solana to confirm the USDC landed, and when the UTC day ends it closes its books on the same number.
Every line in the picture is the node's own log from the rehearsal. The same lines go to your webhook.






