Orrery Node

Machines paying machines. Peer-to-peer AI inference on Solana: your router pays any GPU per answer, 0% cut. Hold $OREY, pay less.

[Orrery Node @OrreryNode]

3,232 downloads in week one.

orrery-node has been on npm since 6 Nov, and the count has gone up every day since.

Turns out a lot of people want to buy AI inference straight from the GPU, with nobody in the middle taking a cut.

We're just getting started.

[Orrery Node @OrreryNode]

Every change to Orrery goes through the rehearsal before it lands: a local Solana validator running our on-chain program, with routers and nodes opening channels, paying per answer and redeeming.

Each new feature brings the checks that prove it. Today's 25 came from privacy, node operator and agent work.

That's how you ship every day and keep the money part boring.

[Orrery Node @OrreryNode]

Put any proxy you like in front of your Orrery node. It still can't read your books.

A node's console and earnings pages now want a key that only lives in the node's own folder. A proxy on the same machine can make its requests look local. It can't read that file.

Which channel paid for which answer stays between the router and your node. In main now, out with the next release.

[Orrery Node @OrreryNode]

You can try Orrery in your browser right now. No wallet, no signup.

https://t.co/pApZX4sgnC

Ask anything. A node on the network answers, the router pays it for that one answer, and the node cashes the payment on Solana within a couple of minutes.

That haiku cost less than a fiftieth of a cent.

[Orrery Node @OrreryNode]

Paying for every answer takes half a millisecond.

That's our router signing the payment for one llama-3.3-70b answer on mainnet: 0.48 ms. Sealing the request to the node took 0.24 ms. Picking the node, 0.1 ms.

The answer itself took 573.7 ms. Everything the router adds came to 0.83 ms.

Pay-per-answer you'll never feel.

[Orrery Node @OrreryNode]

Your GPU can sell inference now.

Run a model, put your price on Solana, and routers pay you for every answer, in USDC, straight to your wallet. Our own node has been paid out 147 times on mainnet already.

Nothing in between takes a cut. The whole price is yours.

Setup is one command: orrery provider init. It even tells you where your prices land against every node already listed.

[Orrery Node @OrreryNode]

New here? This is Orrery, and all of it is open.

Code: https://t.co/av2fW525Y7
Package: https://t.co/UBQZRSL5N9

Orrery is peer-to-peer AI inference on Solana. You run a small router on your own machine that speaks the OpenAI API. It sends each request straight to a node's machine and pays that node per answer through a payment channel. Nobody in between takes a cut: the program's fee is 0%.

What's in it now:
- requests and payment encrypted end to end to the node, so whoever hosts it can't read either
- every node's price list pinned on chain and checked before your router pays
- an MCP server and per-task budgets, so agents can use it on their own
- doctor, which tells you how each request travels

There's been a release every day since 6 Nov. The picture is the commit list as it stands, all MIT.

Try it: npx orrery-node@latest

$OREY is the discount built into all of this: own 0.1% of the supply and every answer from our node costs 20% less. Own 1% and it's 35% off.

[Orrery Node @OrreryNode]

0.1.16 is on npm. That's release 17 since 6 Nov.

This one is about whoever ends TLS for a node: its host, a balancer, a tunnel. Until now it could read which channel paid for each request, so which wallet. In 0.1.16:

- channel and voucher ride inside the seal, under a flag the node signs and your router remembers
- requests padded to a size class, answer frames to 256-byte blocks
- recovery questions, hand-over answers and 402s sealed as well
- doctor, router status and the MCP status tool tell you how each request went

Also: the router waits out a node that's away for a second, finishes paying before it stops, and checks its proxy from the far side before it spends anything.

npx orrery-node@latest

Before every payment the same router reads one balance off chain, your $OREY. Hold 0.1% of the supply: our node bills 20% under list. Hold 1%: 35% under.

[Orrery Node @OrreryNode]

Our node's prices aren't on a pricing page. They're in a list whose hash sits on its Solana listing, and a router won't use the node if the two disagree.

Same list, two more columns. Hold 0.1% of $OREY supply and every model costs 20% less; hold 1% and it's 35% less. The figure is that list as a router read it at 08:20 UTC.

How it gets applied: before paying, your router reads your $OREY balance and the total supply from chain, picks the tier, and pays that price. The node reads the same two numbers and bills the same. Nothing to claim, no promo code, no account.

Orrery's program keeps none of it: 0%. All of the discounted price lands with the node.

[Orrery Node @OrreryNode]

Eight things whoever hosts a node could learn from your request. As of 06:23 UTC on 13 Nov, all eight are sealed.

A node usually sits behind someone else's TLS: a hosting balancer, a tunnel, a CDN. On 11 Nov that front could still see your prompt's length, every token's length, which channel paid (so which wallet), running totals, and the deposit in a refusal. Each one went inside the seal on its own commit, with a rehearsal check that failed on the old code first.

Not everything. Said plainly in the clip: how many frames an answer has and when they go out, a node your router has never reached, and the operator itself, which only an enclave (:private) keeps out.

0.1.11 already has the first one. The other seven ship in 0.1.16.

None of it changes what you pay. $OREY does: a wallet with 0.1% of supply pays our node 20% less, one with 1% pays 35% less. The program in the middle takes 0%.

[Orrery Node @OrreryNode]

If an agent is going to spend money on a network, it should be able to ask how its requests travel. Now it can.

orrery doctor prints a sealing line under every node, and the router's status gives each node one of four values. The status tool an agent calls over MCP says the same thing in words:

inside: request and payment both encrypted for that node alone, under keys it signed
request: request sealed, payment in headers the node's host can read
plain: JSON inside TLS
withheld: the node showed a signed key before and shows none now, so the router sends it nothing

Our node on mainnet reads inside. Node operators get the mirror image in provider check, which fetches their node's encryption key over the internet exactly as routers do.

Ships in 0.1.16, along with everything else this week that moved payment inside the seal.

The same router looks up your $OREY on chain before it pays: 0.1% of supply, and our node charges 20% less. 1% and it's 35%.

[Orrery Node @OrreryNode]

The flag is signed now.

A node that reads payment inside the seal says so in its /v1/wire answer, and the router then keeps which channel pays, and how much, out of headers. That claim was an unsigned field, so the platform in front of a node could delete it and get headers back.

Now the node signs it with its node key, the one on its listing on chain. A router that has seen it signed keeps to it (router/pins.json): strip the flag and payment stays inside; hide the wire key and that node gets nothing in the clear, not a request and not a question about a channel.

The clip is our rehearsal on the real program: the same four checks on the code before the change and after it. Operators get a line for it too: provider check reads the node's wire key from its public address and says when something in front drops the flag.

Left: a host that strips both before your router has ever reached that node. Ships in 0.1.16.

Before each request your router reads one more thing off chain, your $OREY balance: 0.1% of supply knocks 20% off our node's price, 1% knocks off 35%.

[Orrery Node @OrreryNode]

Two things were left open when payment moved inside the seal. One of them is closed.

When your router's records are gone (a new machine, a wiped folder), it looks the channel up on chain and asks the node where it stands: the last voucher the node holds and what it's owed. The question carried the channel in the URL, and the answer came back with the channel and the voucher in the clear, where a node's host could read both.

Now the router asks such a node by POST, sealed to the node's own key, and the answer comes back sealed with the same key. Older nodes are asked the old way. In the figure: both ways as the proxy in front of a rehearsal node carried them, and the same question put to our node on mainnet. Ships in 0.1.16.

Still open: the 'payment goes inside' flag a node publishes isn't signed yet.

Holding $OREY is the other thing that changes what you pay: 0.1% of supply gets 20% off at our node, 1% gets 35%. The program in between takes 0%.

[Orrery Node @OrreryNode]

Your prompt was sealed. Your payment wasn't.

Every request carried two headers: the payment channel and its latest voucher. The platform a node runs on ends TLS in front of it, so it could read both, and a channel belongs to one wallet. Sealed prompt, router behind a proxy, and the host could still count one wallet's requests.

On main, a node says it reads payment from inside the seal, and the router puts the channel and voucher there. The voucher handed over after each answer goes sealed too. The clip is what reached a node's front door in our rehearsal, both ways.

Older nodes still get headers, and new nodes still read them from older routers. Not done: that 'I read it inside' isn't signed yet, and the call a router makes to recover a lost channel still names it. Ships in 0.1.16.

The node still learns one thing about your wallet, from chain and not from a header: whether it holds enough $OREY for the holder price.

[Orrery Node @OrreryNode]

Everything I've posted about this week is in a public repo, MIT licensed. Here's the commit list as anyone sees it.

22 commits went in on Nov 12 UTC, each titled in plain words: requests padded so a proxy can't read their length, a router that checks its proxy from the node's side, a node that stops handing out its balancer's private address, a router that waits out a node restart instead of failing.

The changes come with checks, in a rehearsal that runs the real Solana program, four nodes and a router: 72 of them at the top of that list, all passing.

So don't take a post's word for any of it. Read the diff.

The $OREY discount is in there as well, as code you can read: the price list a node publishes, and the lines in your router that make the node honor it.

[Orrery Node @OrreryNode]

Encryption hides what you asked. It doesn't hide how long it was.

A proxy between your router and a node sees every request's length. In 0.1.15, the release you'd install now, 'Say hi.' and a 644-character prompt went out 852 bytes apart. Anyone in the middle could tell a quick question from a pasted document.

Main pads each request to a size class before sealing it: 1 KiB, doubling to 64 KiB, then every 64 KiB. Same two prompts, same length on the wire. On mainnet, through a proxy to our node, the gap went from 848 bytes to 1.

The padding is spaces, and JSON ignores spaces, so every node already running opens it as before. Ships in 0.1.16.

Answers aren't padded yet. Their length and timing still show.

The router doing this is the same one that reads your wallet's $OREY on chain and pays our node 20 to 35% less for it.

[Orrery Node @OrreryNode]

I cut the path between a router and our node for 4 seconds, on mainnet, with a request in flight.

The router on npm today, 0.1.15, gave up in 8 ms. Then it set the node aside, so the next request got a 503 while the node was already back.

The one on main waited 1.5 s and asked again, waited 3 s and asked again, and got its answer from the same node 5.8 s after it sent the request. The next one went straight through.

Nodes restart. Ours does every time we ship. A restart should cost the caller a few seconds, not an error. That's in 0.1.16.

Each tick in the clip is a tunnel the router actually asked for, at the time it asked.

Each of those answers is billed in USDC from the caller's wallet. Put $OREY in that wallet and our node bills 20% less from a tenth of a percent of supply, 35% less from one percent.

[Orrery Node @OrreryNode]

Seven releases in 31 hours. Here is what was in them, in 30 seconds.

Every screen in the clip is a recorded run, nothing mocked up: a router behind a proxy, one session opening 6 tunnels where it used to open 16, a node telling the router what address it saw, a router that loses its disk and keeps its channel.

And one screen that isn't ours: npm, 888 downloads on Nov 11.

Not in the clip, because it isn't done: a private node on mainnet, and a run through Tor.

$OREY is the token of the network all of this shipped on. Our node knocks 20% off every answer for a wallet holding a tenth of a percent of it, 35% for a full percent. The program in the middle keeps nothing.

[Orrery Node @OrreryNode]

Wipe your router's disk. Your money is where you left it.

A payment channel here lives in three places: the running total on your disk, the last voucher at the node (that total, with your signature), and the deposit on chain. Lose the first and the other two put you back. The router finds its channel on chain, asks the node for the voucher, checks the signature is its own, and carries on from that number.

I ran it on mainnet with a router that had its key and nothing else. It picked up at $0.033109 and signed the next answer at $0.033130.

Two more bad days, handled on main since 11:23 UTC: a node that's out of reach when you come back doesn't cost you a second deposit, and a router told to stop hands over its last voucher before it exits.

Not handled: kill -9 between an answer and its voucher. That one still needs a decision from me.

Same channel, same wallet: when it holds $OREY, the node's holder price applies to every one of those answers.

[Orrery Node @OrreryNode]

888.

That's how many times orrery-node came down from npm on Nov 11. The day before: 390.

Five releases went out that day, 0.1.9 through 0.1.13, and two more since. 2,733 downloads in its first six days on npm.

Nothing to sign up for and no API key to wait on. `npm i -g orrery-node`, and `orrery doctor` shows you the network; fund a wallet and your machine pays a GPU per answer on Solana.

$OREY rides on that router. It checks on chain what your wallet holds and pays the holder price wherever a node lists one: on ours that's 20% off once you hold 0.1% of the supply, 35% at 1%. The program in between takes 0%.