
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
- Tweets245
- Following7
- Followers270
- Likes17
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
Your node now tells you why a payout didn't go out.
The reason shows on its console and in orrery provider status.
It's the chain's own words, plus what to do.
Usually it's a node key with no SOL for the fee.
The node names the key to top up.
What routers signed stays safe meanwhile.
Every round tries again.
Once one goes through, the warning clears.
In the rehearsal: the round fails, SOL goes back, the next round redeems $0.000429.
Merged today. It ships with 0.1.27.
How private is a request you send through Orrery?
Your router now answers that itself.
One sentence, in three places:
orrery doctor
the router console
the status tool your agent calls over MCP
It counts the nodes that take your prompt and your payment sealed to their own key.
It counts the ones running in an enclave your machine verified.
It says whether your traffic leaves through a proxy.
Ask for :private when no enclave node is around, and the router no longer just refuses.
It says why, and what a request without :private still gets.
On main now. Coming in 0.1.27.
orrery-node 0.1.26 is on npm.
19 changes since 0.1.25. Ten of them are on the card.
Nodes can sell a voice and pictures now, beside chat.
Agents get an image tool of their own.
Image bills are held to the pictures that actually arrive.
Node operators get a voucher check before every redeem.
And their books close at midnight UTC, split by kind of work.
npx -y [email protected] doctor
1
7
327
Already done, and still going.
Privacy went into Orrery one release at a time, 0.1.8 through 0.1.17. All of it is on npm.
Your own machine verifies the chip, AMD SEV-SNP or Intel TDX, before a prompt is sealed to it. No attestation service in the middle.
Without an enclave, every request is still sealed to the node's key, so hosts and proxies see only ciphertext.
Client IDs are stripped. Payment travels inside the seal. Tor works for all of it.
Privacy is the part we keep building on.
Screenshots in a prompt now get budgeted the way vision models read them.
Before a request leaves your machine, your router and the node each work out the most it could cost. An inline image (a screenshot pasted into Claude Code, an image_url with a data: URI) now counts as at most 8,192 tokens, whatever the length of its base64. Text still counts at 4 characters a token.
From the rehearsal: a prompt carrying a 400,000-character screenshot, with a $0.002 budget for that one request. Answered, for $0.001653.
On main, out with 0.1.26.
3
13
468
Everything Orrery shipped in the last day went public as it landed, on github.com/orrery-node/orrer…:
nodes sell speech and images next to chat, on the same payment channels
provider init recognizes rerankers, speech and image models on your server
orrery quote prices speech by its text and images by the picture
provider vouchers checks the money a node holds the way the program will
your router pays for no more images than came back
Each of those commits brought a rehearsal check that failed on the code before it, and passed after. MIT licensed.
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.
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
10
357
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
426
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
10
436







