The dendritic network
how the dendritic network is actually put together
One program, dendritic-node, runs on every machine in the network. Its owner
switches on the roles they want, and every role is paid in AXON, the network’s token.
This page shows how the parts fit together, one picture at a time, and ends by setting up a
node of your own.
During development the network’s contracts are on Ethereum Sepolia, a test chain, so AXON has no cash value yet. In every figure a dashed box is designed but not running, and a dashed line is an anonymous circuit over AXON, the network’s own overlay. Grey “+” panels hold detail you can skip.
Chapter 1
The parts, and how they connect
People reach rabbiit.io through a gateway, or reach anything on the network anonymously through relays. Behind the relays are the nodes that do the work and the nodes that move money, and the parts that need a public record meet on one blockchain.
Dashed lines are anonymous circuits over AXON.
- Relays
- carry the anonymous circuits. A new node finds its first relays in the bootstrap registry on Sepolia, so joining needs no central server.
- Service nodes
- do the work: storing encrypted shards, running compute jobs and containers.
- Payment nodes
- let people pay each other in AXON without a fee on every payment.
- Watchtowers
- stop a cheat from closing a channel on an old balance.
- Checkers
- test the front doors from outside.
- Every node is also a witness:
- the protocol draws it at random to check other nodes’ work, and that check is what gets them paid.
Every role: what it does, how to switch it on, what earns it 16 roles
Storage
Keeps encrypted shards of other people’s files.
Switch it onOn by default (capacity_bytes)
Earns AXON forAnswering storage audits with Merkle proofs
Relay
Carries anonymous circuits.
Switch it onaxon.relay plus a reachable port
Earns AXON forA witness reaching it through a real circuit
Gateway
A public HTTPS front door for rabbiit.io.
Switch it ongateway.enabled
Earns AXON forIts signed identity and readiness, checked by a witness
Probe
Tests gateways from outside.
Switch it ongateway.probe_enabled
Earns AXON forAnswering a witness’s probe correctly
Monitor
Watches whether services are up.
Switch it onmonitor.enabled
Earns AXON forIts checker catching a witness’s planted failure
Validator
Audits that gateways serve content unaltered.
Switch it ongateway.validator.enabled
Earns AXON forGrading a witness’s signed and tampered test objects correctly
Compute
Runs catalogue work units.
Switch it oncompute.enabled
Earns AXON forResults of witness-chosen work units, re-run by the witness
MicroVM
Runs arbitrary code inside a Firecracker VM.
Switch it oncompute.microvm_kernel and microvm_rootfs (Linux with KVM)
Earns AXON forThe same as compute
Container worker
Runs containers for the Distributed Container Service.
Switch it ondcs.enabled, dcs.role.worker
Earns AXON forThe same as compute
Payment node
Holds AXON payment channels and receives tips.
Switch it onchannels.enabled
Earns AXON forNothing by itself; the router, watchtower, mailbox and delegate build on it
Router
Forwards other people’s payments between its channels.
Switch it onrouter.enabled
Earns AXON forA signed liveness check plus an open channel, and routing fees
Watchtower
Challenges a channel closed on an old balance.
Switch it onrouter.watchtower_enabled
Earns AXON forLiveness while its sweeper runs
Mailbox
Holds tips for recipients who are offline.
Switch it onchannels.mailbox.enabled
Earns AXON forLiveness of its key
Delegate
Signs channel updates for recipients who opted in.
Switch it onchannels.delegate.enabled
Earns AXON forLiveness of its key
Draining
Retires a node: moves its shards away and accepts no new ones.
Switch it on"draining": true
Earns AXON forNothing; it is leaving
Witness
Checks other nodes and countersigns their receipts. Drawn evenly from registered nodes, never one run by the provider’s own owner.
Switch it onAutomatic
Earns AXON forEach of its checks that is counted
The roles combine freely on one node. Every role except the gateway and the probe needs the default storage run mode to be paid, because that mode runs the peer-to-peer host the witnesses talk to.
Chapter 2
Reading a page
Reading rabbiit.io goes browser → gateway → origin, over ordinary HTTPS. Gateways are run by strangers, so the design makes it impossible for one to change what it carries without being caught.
What happens when you ask for a page
Five steps, of which only one involves trusting anybody. The gateway is carrying bytes it cannot alter without the reader noticing, which is what makes it safe to let a stranger do it.
The gateway never holds the signing key. That is the whole design.
Stored content works the same way: in the DHT a thing’s name is its hash, so a storage node that returns the wrong bytes is caught by whoever asked, and never has to be trusted.
What happens when the origin is down
Step 3 fails. Gateways already hold a signed, read-only snapshot of the site, so the answer is not an error page — it is the site, clearly labelled as a copy, with everything that writes turned off.
The snapshot carries its own signature and its own version, so an outage cannot be used as cover for serving something older or altered.
How a gateway is judged
A gateway that misbehaves has to be removed, and the power to remove one is the power to remove a competitor. So no single observer has it. A finding counts only when several independent ones agree — and independence is checked, not assumed.
The counts are the network's live thresholds. They are deliberately hard to meet.
Being honest about where this stands
Those thresholds are real and enforced, which means that today — with few independent operators — almost nothing reaches quorum. That is the correct behaviour and not a finished one: a rule that never fires is doing its job only until there are enough participants for it to matter. Running a probe is how that changes.
What happens if the domain or the server is taken
An outage is the easy case. A seized domain and a dead server are harder, because both break the thing everything else is looked up through. The overlay does not depend on either: a new node finds its first relays in the bootstrap registry on Sepolia. Where the website lives is a document signed by the operator’s wallet, which a joining node checks with several gateways.
Two forgers do not outvote one signature — which is why agreement is the second layer and never the first.
Six defences, and what none of them fixes
DNS is not the authority
Where the network lives is a document signed by the operator's wallet. Nodes keep the last one they verified and prefer it over anything a name resolves to — because a name is exactly what gets taken away.
Your node checks it itself
Against a wallet address written into your config when you downloaded it, never fetched. Asking the origin who is allowed to replace the origin would be asking the thing being replaced.
Old instructions cannot be replayed
Every directive carries a number that only moves forward, and your node remembers the highest it has seen — across restarts. A message captured today is worthless tomorrow.
A move waits, on purpose
An ordinary move takes effect after a delay. That gap is the window in which a directive nobody meant to issue can be frozen. A genuine emergency skips it and is announced loudly instead — speed is paid for with visibility.
Backups nobody can read
The site can be rebuilt elsewhere from an encrypted backup held by gateways. Holding one reveals nothing: it is opaque to its custodian, and opening it needs a passphrase no server has. Copies are spread across distinct operators, since five copies with one person is one copy.
The way in is not one address
A joining node finds the network through several gateways discovered in DNS, so one being offline costs nothing. What it is told is signed, and when it cannot verify a signature it requires independent gateways to agree before believing anything.
What none of this fixes. One wallet signs those directives, so whoever holds it can move the network. The delay, the freeze and the forward-only numbering narrow that window; they do not close it. The real answer is a second independent signer, and that needs a second operator to exist — which is one more reason to run something here.
Chapter 4
Lending your spare CPU — without lending your machine Live on Rabbiit’s nodes
Compute here is CPU-first. Two processors running the same code over the same input produce byte-identical output, so a witness can check a result by running the work again and comparing hashes. Graphics cards do not offer that: different scheduling changes the order of additions, and the answers are all correct without being equal.
Running a stranger’s program on your desktop is exactly the thing you should never do. So the design assumes every program is hostile and removes what malice needs, rather than trying to detect it:
Runs today on Rabbiit’s compute nodes. MicroVM jobs need Linux with KVM.
Why each ring is enough on its own 4 notes
Nothing to block
A keylogger needs a keyboard stream; screen capture needs a framebuffer. A headless VM has neither, so there is no attack to detect — there is nothing for one to attach to.
No network at all
Not filtered — absent. No interface, no route, no DNS. Inputs are fetched before it boots and results collected after it stops, so there is no botnet to join and no allowlist to leak through.
It stops when told
There is no polite shutdown to ignore. The deadline passes and the machine is destroyed, along with anything it started. A job cannot hold your core by declining to exit.
Wrong answers are caught
A witness picks a work unit, runs it again and compares the result. Two honest processors agree to the byte, so a wrong answer has nowhere to hide.
Chapter 5
How money flows
There are three streams, all in AXON: rewards pay nodes for witnessed work, compute is paid by the people who rent it, and payments and tips move between people, off chain. Payments run today on Sepolia; the reward and escrow contracts are not deployed yet.
Rewards pay nodes for witnessed work Not deployed yet
Each epoch lasts one hour. Its budget is split between the services by an on-chain policy, capped per node, and paid only for receipts that witnesses signed. Operators claim their share to their payout address. What nobody claims within a year is burned, so it can never become spendable treasury money.
Compute is paid by the people who rent it Escrow not deployed yet
Each job’s price is held when it is submitted. A finished job is charged in full; a job that never ran costs nothing. Until the escrow contract is deployed, the site holds deposits in the Treasury and pays providers from it.
Payments and tips move between people, off chain Live on Sepolia
Dashed: off chain, over AXON. Solid: a transaction on Sepolia.
Two parties lock AXON in the AxonChannels contract once, then pay each other off chain with no network fee per payment. Routers carry payments between people who share no channel, and a mailbox holds tips for a recipient who is offline. The balance reaches the chain when someone settles or closes the channel.
The routing fee, and what a router can and cannot do
A router keeps a fee of
ceil((base_fee_milli × 1000 + amount × proportional_fee_ppm) / 1 000 000)
It forwards; it does not hold
Each hop is locked to a secret that only completes the whole path at once. A payment either reaches the payee or never leaves your channel — there is no in-between state where someone else is holding your money.
You can always leave
Your channel is still yours. If a router stops responding you close the channel yourself and the chain returns your remaining balance after a waiting period, whether or not anyone cooperates.
The honest catch
A router sees what it routes, so it learns who paid whom. On a network built for anonymity that is a real cost, and it is being designed against rather than ignored.
Delivered, never minted
AXON bought with a card is delivered from the OrderDesk, a capped float: at most 1,000 AXON per order and 5,000 per day. Card sales are switched off while the network runs on a test chain.
ETH is spent, never earned
The network pays only in AXON. Anything that sends a transaction pays its gas in ETH: opening, settling or closing a channel, a watchtower’s challenge, or claiming rewards. On Sepolia that ETH comes free from a faucet.
Chapter 6
How a node earns Not claimable yet
Nobody is paid for saying “I’m online”. Witnesses the node cannot choose test its work, and only what they countersign is paid. The witness checks run in the node today; the contracts that pay for them are approved for Sepolia and come next.
Dashed steps wait for the reward contracts. Until then a node records what it earns without signing it.
Witnesses are drawn evenly
From registered nodes. Stake is only a floor for being eligible, so buying AXON does not buy more draws. A witness run by the provider’s own owner is never counted.
Receipts name their deployment
Every receipt carries the chain id and the EpochManager contract, so a receipt from one deployment cannot be replayed on another.
A false reward list costs a bond
An aggregator that posts one loses its bond, and cannot withdraw it while its epoch can still be disputed. Half of a slash goes to the first challenger, the rest to the Treasury.
How each epoch’s budget is split Proposed
Storage is paid per audit answered instead of per slot, and routers also keep the fees they earn, in their channel balances. The proposed first policy splits each epoch’s budget like this:
Share of each epoch’s reward budget, by service (proposed policy v1).
REWARDS.md has each role’s check, and what a payment does and does not prove.
Node reputation
How the network rates the machines that keep it running. Scores are derived from evidence anyone can fetch — the receipts nodes signed and the epochs that settled them — so they can be recomputed by anybody who doubts them.
No nodes registered yet.
A node appears here once it is on-chain, and earns a rating by proving its work and by auditing other nodes. How to run one ↓
How a score moves
| Proof accepted | +1.0 | proved it holds what it claims |
| Challenge verified | +5.0 | audited another node and confirmed the result |
| Proof failed | -0.3 | could not prove what it advertised |
| Fraud | -20.0 | a fabricated or duplicated receipt |
| Caught cheating | -100.0 | attestations from witnesses nobody drew |
Every node starts at 50 — neither trusted nor suspect. Gains are slow and penalties are not, because a reputation that is cheap to rebuild is not worth protecting. Being unreachable is never counted as dishonesty: an offline node earns nothing, which is punishment enough for downtime.
This score is not a contribution point. Contribution points are a separate record of verified work, and they are designed, not live. Contribution records →
Chapter 7
Payments, in depth
Payment channels run on Sepolia today, between Rabbiit’s own nodes. This chapter is for anyone deciding whether to trust them with money: why an off-chain payment is safe, who carries tips while you are offline, and which protections are still being built.
Why an off-chain payment is still safe
If a payment is not recorded publicly, what stops the other side denying it? A payment channel does not ask you to trust anyone. It gives you something you can take to the chain alone, at any time, whether or not the other side cooperates.
Live on Sepolia, so far between Rabbiit’s own nodes.
Four guarantees, and the parts that are not magic 8 notes
This is the design Bitcoin’s Lightning Network proved at scale. The dendritic network is not Lightning — Lightning is Bitcoin, and this settles on Ethereum — but the safety mechanism is the same one, and it is what your money actually rests on.
You can always leave
Every update is signed by both sides. If the other party disappears, you submit the newest one you hold and the contract pays it out after a waiting period. Their cooperation is convenient, never required — which is the whole reason this is not trust.
Cheating is punished, not merely detected
Submitting an old state — one where you had more — opens a window in which anyone can post a newer signed state and take the cheat's stake. Fraud is not just refused; it is the losing move.
You are not required to be online
The catch in that window is needing to notice. A watchtower watches for you and submits the newer state if someone tries it, and it is built so it can only ever pay you — it can never move your funds anywhere else.
Nobody holds your money in between
Funds sit in the contract, not with an operator. Between opening and closing, what changes hands is signatures — not custody. There is no moment where the site is holding your balance and could freeze or lose it.
And the parts that are not magic
Your funds are only as safe as your keys
The signed states are what protect you. Lose them and lose the device with no backup, and you can still recover what the chain last recorded — but not what you were owed off-chain since. Endpoint compromise defeats all of this.
Opening and closing are public
What happens inside a channel is private; that a channel exists is not. Deposits, withdrawals and timing are on a public chain, and no amount of off-chain privacy changes that.
Money in a channel is committed
Funds locked in a channel are not spendable elsewhere until it closes, and closing costs a transaction fee. Channels suit repeated small payments; for one large payment they are usually not worth opening.
It runs on a test chain
Channels are live on Sepolia, where AXON has no cash value, and so far only between Rabbiit’s own nodes. Watchtowers only watch and alert for now. When that changes, this page will say so.
Carrying other people’s tips
A channel payment needs the recipient to approve it at the moment it happens, which used to mean every creator had to run a node. Two roles lend creators the one thing they were missing: a machine that is awake. Neither ever holds anyone’s money. Payouts are written into the contract and go to the creator’s own address.
Tipping mailbox
You hold incoming tip messages for creators who are offline, and hand them over when the creator’s browser comes back. You hold no keys, approve nothing, and cannot change a message you are carrying.
The tip finishes when the creator returns. This is the safe default and needs no trust from anyone.
Delegated signer
A creator can authorise you on the blockchain to approve their incoming tips, so a tip completes even while they sleep. The contract limits that authority to agreeing the new balance: you cannot withdraw funds, close a channel, or be paid.
The creator can revoke you at any moment. It asks real trust of you as an operator, so it is opt-in on both sides and never turned on by accident.
The creator’s key never leaves their machine, so the accepting step can only happen there — not in a web page, and not here.
Where you accept tips, and what a volunteer can see
Where you accept them. Reviewing and accepting tips happens in your own node’s console, not on this site. Accepting a tip means signing with your channel key, that key lives in your node so tips can arrive while you are asleep, and a web page that could accept on your behalf would be a web page holding your key.
What a volunteer can see. A tip message names the two people it is between, so a mailbox learns who is tipping whom and roughly how often. Running a mailbox is not anonymous relaying, and hiding that relationship needs a further layer that does not exist yet.
Mailboxes for browsers. A browser can reach a mailbox only once the node’s peer surface speaks HTTPS. Payments over AXON work without it.
Who watches while you are asleep Detect-only today
A channel protects you by letting you post a newer signed state than the one a cheat submitted — before a deadline. A watchtower holds your newest states and posts one if it sees an older one hit the chain. Today the network’s watchtowers watch and alert; they challenge only once given an external signer.
A watchtower can only ever replace a stale state with a newer one you already signed.
It never holds a key that can move your money. Everything it stores is a state you already signed, and the only action it can take is handing one of those to the contract. A compromised watchtower can fail to defend you; it cannot rob you.
The waiting period is a measurement, not a guess
How long should the challenge window be? Too short and an honest person cannot react in time. Too long and everyone’s money is slow to withdraw. The number is fixed permanently when the contract is deployed, so it was worked out by measuring every step of getting a newer state onto the chain, rather than by picking a round figure.
Each step has a generous budget, and each budget has to be backed by an actual measurement against real Ethereum. Four are done. One is not, and the reason is worth being precise about: a reorganisation is a rare event, and watching for a long time without seeing one does not prove they are shallow. An absence of events cannot bound the size of one, so that budget stays unproven until a real reorganisation is observed and measured.
If your device dies In development
The signed states are what protect you, so losing them matters. Your latest states are backed up encrypted, split into pieces, and spread across the same distributed storage that holds the site’s content — so recovering them does not depend on any one machine still being alive, including ours.
What a backup does and does not protect
Storage is not trust
The nodes holding your backup hold ciphertext. They cannot read a state, cannot forge one, and cannot use one — a state is only worth anything to the person it pays.
Losing pieces is expected
The backup is split so that any six of nine pieces rebuild it. Nodes going offline is normal operation, not an incident.
What a backup cannot fix
If your signing key is stolen, backups do not help — whoever holds the key is you, as far as the contract is concerned. Backups protect against loss, not against compromise.
How we know the blockchain is telling the truth In development
Most applications ask a company’s server what the chain says and believe the answer. Here that would be dangerous: a watchtower shown a fabricated chain would sit quietly while your channel was stolen. And since Ethereum stopped using proof-of-work, fabricating a convincing chain of block headers costs nothing — checking that blocks fit together proves nothing at all.
The only thing that makes a block real is signatures from Ethereum’s validators — so those are what we check.
So the node checks the validator signatures itself. It starts from a reference point obtained from three unrelated organisations who must agree exactly, then follows Ethereum’s own signature chain forward from there. The server we read blocks from is never allowed to supply that starting point.
Three rules it keeps
It fails closed
If the signatures cannot be verified, the answer is refused. There is no best-effort mode that quietly falls back to believing the server, because that mode would be the one running on the day it mattered.
Agreement is not the security
Asking several providers and taking the majority raises the cost of an attack; it does not prove anything. It is used to obtain a starting point, and it is never described as verification.
Verified against the real chain
This is not a diagram of an intention. It has been run against live Ethereum mainnet: real validator signatures checked, real balances proven underneath a block the node confirmed for itself.
Designed, not built yet
Three payment features exist as designs. Each one says plainly what is missing.
Giving an award without a transaction fee
Design
Sending an award on-chain means paying a transaction fee that can exceed the award itself. Over a channel an award is a signed message: instant, free, and settled later in bulk with everything else.
One deliberate constraint shapes the design: clicking the award button does not decide that you paid. The click starts a payment; the payment completes only when both sides have signed a new channel state. The awards you see and the money that moved are kept as separate machinery so that a bug in one cannot invent the other.
Three outcomes, not two
A payment completes, is refused, or is unknown — the last when a reply is lost. Unknown is treated as its own case rather than guessed at, because guessing wrong either double-pays or loses a payment.
Retrying cannot double-pay
Each award carries an identifier the channel remembers. Sending the same one twice updates nothing the second time, so a flaky connection costs you a retry, not a second award.
Splitting one payment across several routes
Not enabled
A larger payment can be cut into pieces that travel different routes and reassemble at the recipient. It helps when no single route has enough capacity, and no single intermediary sees the whole amount. The planning half is built: fragments are sized unevenly on purpose, and the routes chosen must share no operator.
It is switched off, and it should be. What is missing is the half that coordinates the pieces once they are in flight: what happens when two of three arrive, how partial refunds reconcile, how a payment resumes if your machine restarts midway. Until that exists, splitting a payment would place real locks on real channels with no coordinated way to settle or unwind them — worse than not splitting.
Pooled tipping — many people, one recipient
Design
Many independent people contribute toward one recipient, aggregated so a streamer draws down a single total rather than settling hundreds of separate tips.
Each contribution stays backed by its contributor's signature. The pool adds them up; it never invents them.
The line this design will not cross is the obvious shortcut: a pool must never become a database that records Alice owes 1, Bob owes 5 and then promises to pay the streamer. That is a custodian with extra steps.
The recipient chooses
Pooling is a per-recipient setting, off by default. Ordinary one-to-one tipping stays the default — a tip is never forced through a pool.
It sits above channels, not instead of them
The underlying channels stay two-party. This is an aggregation layer on top of the same signed states, not a redesign into multi-party channels.
A retry is not a second tip
The same contribution sent twice must leave the pool at plus twenty-five, never plus fifty.
You cannot hand it a total
A contributor asks to tip a recipient an amount. They never submit a balance or a pool state — a caller who can choose the state can choose a flattering one.
This is a design, not a running feature. It is scheduled after the economic testing phase, and how a contribution is bound to its contributor, recipient, pool and amount at once is still an open question.
Chapter 8
Who can change the network Designed, not live
In the design, no single key controls the network’s contracts. Every change waits in a timelock where anyone can see it, for a delay set by how much the change matters. None of it is deployed yet; who holds the controls today is under what is true today, below.
Every box is dashed: the timelock is approved for Sepolia with the reward contracts; governance is written, not deployed.
- The Safes are multisig wallets. During development their signer keys are spread across Rabbiit’s machines, so one compromised machine cannot act alone.
- Changing the delays, the token, or who can propose is constitutional: it waits 30 days.
- Granting a role is classed by the role it grants. Day-to-day roles (the delivery and settlement keys) take 7 days to change; admin roles are constitutional.
The economy
AXONCoins (AXON) are the network’s utility token. The design pays them to people who run infrastructure that others verify, and spends them on the platform’s services. The live figures, every contract and who controls it are on the records pages.
What is true today
- The AXON token is live on Sepolia. Its genesis supply was minted to the token owner's address.
- Genesis is open. The owner can still mint, and can name a minter at any time.
- The reward contracts are not deployed. No node is paid in AXON yet.
- No buyback, no fee burn, no reserve rule, no network health index and no reward multiplier is live. No contract does any of these today.
- No governance weighting is live. The only vote is an off-chain poll on this website: one member, one vote, with no on-chain authority.
Three balances, kept apart
AXON
AXON is a utility token used to pay for network services and to reward verified infrastructure work.
Holding AXON does not give you ownership, profit rights, or any claim on a treasury.
Today: the token is live on Sepolia. The reward contracts are not deployed, so no node is paid in AXON yet.
Contribution points
Contribution points record verified work. They cannot be bought or transferred.
Contribution points do not by themselves give ownership.
Today: designed, not live. The contribution contracts are not deployed, so no points exist.
Ownership units
A mirror of a legal entity's ownership register, kept apart from AXON and from points.
No legal entity or register exists, so no ownership units exist.
Today: none. On this testnet, no ownership interests exist.
None of the three is computed from another. AXON never buys points, and points never turn into AXON. No ownership record reads an AXON balance.
AXON also bonds the aggregators that post reward lists. Contribution points are counted per month and are one of four inputs to voting weight, with infrastructure, stake and participation. Ownership units run only as a simulation with made-up holders until counsel approves.
Supply: what limits it Designed, not live
Today the token’s owner can still mint, because genesis is open, and can name any address as the minter. So today nothing but the owner’s key limits supply. The design moves the token to a timelock and lets only the AXON Treasury mint, for finalized epochs, under a hard cap.
A budget and a cap
The AXON Treasury mints only for a finalized epoch, within a per-epoch budget and a hard supply cap. Any change to who can mint waits 30 days in a public timelock. The contract is written, not deployed.
No market tools
No buyback, no fee burn, no reserve rule, no network health index and no reward multiplier. No contract does any of these today.
Spending & who decides
Paying for services
AXON pays for network services such as rented compute. Compute is priced in AXON per core-second, and the price rises when the network is busy. No fee is burned.
Contribution, not wealth
In the design, voting weight comes from verified work: 40% infrastructure, 30% contribution points, 20% participation, 10% bonded stake. Holding AXON alone gives no vote. Today no governance weighting is live. The only vote is an off-chain poll on this website: one member, one vote.
The records
Every contract, its owner, its delays and its balance, read from the chain. Contract directory →
Chapter 9
What runs today
The network Rabbiit runs right now. There is one public overlay: the six cloud relays listed in the bootstrap registry. Every service node joins through them, including the ones in the home lab and on the site host, which reach the cloud relays outbound from behind NAT.
Every node heartbeats to rabbiit.io, which draws the network map. Every relay also runs a probe; every node stores shards and acts as a witness.
The payment channels between Rabbiit’s nodes
Three channels on Sepolia, each holding 400 test AXON on both sides.
What is live, and what is not yet
State on 14 October 2026
- Live
AXON token, AxonChannels, the bootstrap registry,
.axonnamesLive on Sepolia.
- Live
Every role, running and on the network map
Live on the reference network. Rabbiit’s nodes pay out to its Sepolia admin wallet.
- Live
Routing
Live on Sepolia between Rabbiit’s own nodes: three funded channels (400 test AXON on each side). A payment routed through both routers completed off chain, with no gas.
- Live
Compute
The catalogue image is published, the cloud worker runs catalogue and microVM jobs, and the home-lab host runs microVM jobs.
- In the node
Slot receipts, witness checks and signed registration
Receipts are bound to one deployment, so until the reward contracts exist a node records what it earns without signing it, and its registration waits.
- Next
Reward contracts
NodeRegistry, EpochManager, RewardDistributor, Treasury, OrderDesk, ServiceEscrow and the timelock: fixed after an independent review and rehearsed end to end. Deployment to Sepolia is approved and next; no reward can be claimed until then.
- Not deployed
Contribution registry, contribution-weighted governance, the ownership layer
Written and rehearsed (ownership as a simulation with made-up holders only).
- Detect-only
Watchtowers
They watch and alert, and challenge only once given an external signer.
- Limited
Mailbox for browsers
Needs HTTPS on the node’s peer surface; payments over AXON work without it.
- Live
Relays
A circuit now ends with the session it carried, and an idle one is reaped after 30 minutes, so a relay no longer fills up with the circuits of endpoints that stopped using them. It used to refuse new circuits after about a day.
Running a node earns AXON once the reward contracts are deployed. It never gives ownership of the network.
Chapter 10
Run a node
Four steps. Pick your roles below and this page builds the configuration and the install command for you.
The node’s own guide covers each role:
a gateway,
a container worker,
a watchtower,
a payment node or router.
To join the public overlay, leave axon.seeds empty.
Pick your roles
Click a role to select it. You can pick more than one — a single machine happily runs storage and validation together. Several need an open port; each card says so.
About that open port. A gateway and a probe both have to be reachable from the internet, which on a home connection usually means adding a port-forwarding rule on your router. If your provider uses carrier-grade NAT — common on mobile and some fibre plans — inbound connections are not possible at all and neither role will work. Storage and validation have no such requirement: they reach the network over AXON and make only outbound connections.
Build your configuration
Everything below goes into a config.json packaged beside the program.
Nothing here is permanent — every value can be edited afterwards, and the node has a
management page for exactly that.
Set your disk size so the bar means something. Your browser is not allowed to read it, so these two numbers are yours to fill in — nothing is measured or sent.
The payout address is where AXONCoins are sent. Leave it blank and the node still works — it simply earns nothing, which the node's own dashboard will nag you about.
Download
The program is identical for everyone on a platform. Only the configuration differs, which is why the hash below is of the binary — a hash of your personal archive would match nobody else's and could not be checked against anything.
No binaries are published yet. Everything below works — you can pick roles and build a configuration — but the download itself will not be available until an operator uploads the builds. Nothing here is broken; there is simply nothing to hand you.
Guessed from your browser. Guessed, not known — a browser will not tell a site which processor it has, so check this is right before downloading.
Expected SHA-256 of the binary
Nothing selected yet.
After it is running
It is designed to earn AXONCoins
The reward contracts are not deployed yet, so no node is paid today. In the design, every role is paid per settled epoch, and rewards are claimed, not pushed — your share becomes provable against a Merkle root and you send one transaction to collect it. How a node earns ↑
It has its own dashboard
Served on 127.0.0.1:9090 — local only, so nothing about
your node is exposed by running it. Capacity, peers and earnings live
there, and every setting in config.json can be changed
afterwards.
Stopping is not a betrayal
Shards are erasure-coded across many nodes, so leaving costs the network redundancy it will rebuild, not data. Run it for as long as it suits you.
Its network is built in
Storage and validation reach the network over AXON, the network's own
anonymous overlay, which is part of the node: there is no router or
proxy to install and no port to open. Relaying for other nodes is
optional and needs a port the internet can reach — set
axon.relay and axon.listen in
config.json if you have one.
Run it — one line
This fetches the installer, picks the right binary for the machine you run it on,
writes a config.json for the roles you picked above, and starts the node.
It changes as you change your selection. It is an ordinary shell script and you are
welcome to read it first —
open it in a browser before piping it into a
shell.
Paste this into a terminal
curl -fsSL https://rabbiit.io/install.sh | sh
Nothing selected yet — this installs the node with the installer's defaults. Pick roles under “Pick your roles” above and this line updates to match.