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]

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%.

[Orrery Node @OrreryNode]

Every privacy tool has a setting that says you're hidden. I wanted the other end to say it.

So a node now answers one question: what address did this request come from? `orrery doctor` asks it through your proxy and prints what comes back.

In the clip: with no proxy the node sees me. Through a proxy it sees the proxy. Through a proxy that quietly writes my address into a header, the line goes red. Those three runs are two addresses on one machine; the last line is our mainnet node, with my address covered.

Not done: behind a home router your computer doesn't know its own public address, so there the tool prints what the node saw and you do the comparing.

0.1.13 went out at 23:14 UTC, 0.1.14 at 04:02, and 0.1.15, with this in it, at 08:35. Three releases in under nine and a half hours, a privacy change in each.

Run `npx -y orrery-node@latest doctor` and it prints what our node sees of you right now.

The one thing a node does need from you is a wallet. When that wallet holds $OREY, a node with a holder price charges it less.

[Orrery Node @OrreryNode]

Most token utility is a sentence on a landing page. Here is $OREY's, as three pieces of code.

A node lists a holder price in its manifest. Ours: a fifth off once your wallet holds a thousandth of the supply, 35% off at a hundredth.

When your request arrives, the node reads your balance from chain and prices the answer.

Then your router does the same sum on your own machine. A node that lists a discount and doesn't apply it gets marked down in your router's ranking.

No tier page, nothing to claim. The price change in the picture is from our rehearsal run; the tiers are live on our node now.

[Orrery Node @OrreryNode]

0.1.14 is on npm. Private shouldn't mean slow.

With a proxy in the path, 0.1.13 opened a tunnel for nearly everything: 16 for three requests. 0.1.14 keeps them open: 6 for the same three, and the requests added up to 5.4 s instead of 7.4. One run each on mainnet, so trust the direction more than the decimals.

It speaks SOCKS5 now too, so the proxy can be the one you already run.

Main is already down to 3 tunnels. That ships next.

Fifteen releases in six days. Hold $OREY and every answer on this is 20% to 35% cheaper at our node.

[Orrery Node @OrreryNode]

I fed my router two public sample attestations, one Intel TDX and one AMD SEV-SNP. It refused both.

Intel: 7 of 8 checks pass. The platform is older than every patch level Intel still supports. Refused.
AMD: 6 of 7 pass. The VM was launched with debugging on, so the host can read its memory. Refused.

That's the private route. Your own router checks the chip against Intel's and AMD's roots before it seals a prompt. No attestation service in between, and a failed check means no request, not a warning.

No enclave node is live on mainnet yet. The verifier ships in 0.1.13 so the first one gets checked like this.

$OREY holders pay 20% to 35% less at our node, on the same network.