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.

Checkers probes · monitors validators People browsers · apps anonymOS Gateways public HTTPS front doors Relays the AXON overlay, anonymous circuits rabbiit.io the origin Service nodes storage · compute microVM · containers Payment nodes routers · mailboxes delegates Watchtowers guard payment channels Ethereum Sepolia AXON token · payment channels · bootstrap registry · names · reward contracts (next) test from outside HTTPS anonymous circuits fetches pages settles rewards designed, not live open and settle channels challenge stale closes the relay list to join through Checkers probes · monitors validators People browsers · apps anonymOS Gateways public HTTPS front doors Relays the AXON overlay, anonymous circuits rabbiit.io the origin; settles rewards: designed Service nodes storage · compute microVM · containers Watchtowers challenge stale channel closes Payment nodes routers · mailboxes delegates Ethereum Sepolia AXON · channels · registries · names reward contracts: deployment next test HTTPS anonymous

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.

1 · Your browser picks a gateway from a signed list 2 · Gateway terminates TLS under its own name 3 · Origin renders and signs path + version + hash 4 · Gateway relays cannot re-sign: it has no key 5 · your browser checks the signature against the origin key it already holds a changed byte fails here — detected by the reader, not reported by a third party the version is signed too, so replaying an old page is refused rather than merely noticed 1 · Your browser picks a gateway from a signed list 2 · Gateway terminates TLS under its own name 3 · Origin renders and signs path + version + hash 4 · Gateway relays cannot re-sign: it has no key 5 · Your browser checks the signature against the origin key it already holds a changed byte fails here — detected by the reader, not reported by a third party the version is signed too, so replaying an old page is refused rather than merely noticed

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.

Your browser asks as normal Gateway origin unreachable origin — not answering Signed snapshot served read-only, and labelled Posting is disabled, not broken: a form that silently swallows what you typed is worse than one that is absent. Your browser asks as normal Gateway origin unreachable Origin not answering Signed snapshot served read-only, and labelled Posting is disabled, not broken: a form that silently swallows what you typed is worse than one that is absent.

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.

probe A operator 1 probe B operator 2 probe C operator 2 — same Quorum 4 of 5 agreeing 3 operators, 2 networks Acted on reputation, then removal with the evidence kept Probes B and C are one operator, so they count once. Agreement between machines somebody controls together is one opinion wearing three signatures. Probe A operator 1 Probe B operator 2 Probe C operator 2 — same Quorum 4 of 5 agreeing 3 operators, 2 networks Acted on reputation, then removal, evidence kept Probes B and C are one operator, so they count once. Agreement between machines somebody controls together is one opinion wearing three signatures.

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.

A joining node no peers yet, so it cannot ask the network gateway A signed answer gateway B same answer gateway C offline — skipped Checked, then joined signature first, agreement second A gateway that answers differently from the signed document is named, not merely ignored. A joining node no peers yet, so it cannot ask the network Gateway A signed answer Gateway B same answer Gateway C offline: skipped Checked, then joined signature first, agreement second A gateway that answers differently from the signed document is named, not merely ignored.

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 3

Reaching a hidden service

A hidden service is reached at a .key.axon address, which is its public key, or at a registered .axon name. It works like Tor: neither side connects to the other. Both build circuits to a meeting point.

Client your browser or app Rendezvous relay picked by the client Intro relay one of the service’s three Hidden service .key.axon or an .axon name Neither side learns the other’s IP address 1 · keeps circuits open to 3 intro relays 2 · builds a 3-hop circuit to a rendezvous relay it picks 3 · sends an introduction over another circuit 4 · passes the introduction on 5 · builds its own circuit to the rendezvous relay 6 · joins the two circuits Client you Meeting relay Intro relay Hidden service Neither side learns the other’s IP address 1 · The service keeps circuits open to 3 intro relays 2 · You build a 3-hop circuit to a relay you pick 3 · You send an introduction over another circuit 4 · The intro relay passes it to the service 5 · The service builds a circuit to your relay 6 · The relay joins the two circuits

Every arrow is a circuit over AXON. The meeting point is the rendezvous relay.

Every circuit starts at a pinned guard relay and has three hops, so no single relay sees both ends. ANONYMITY.md has the details.

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:

Your machine your files, your network, your devices — none of it reachable from inside microVM — a real virtual machine, not a container hardware virtualisation: the guest cannot read host memory even if it fully compromises its own kernel; privileged instructions trap to the hypervisor The job reads its input computes writes one output file boots in under a second, destroyed when finished No network absent, not firewalled No devices no camera, mic, USB No keyboard, no screen nothing to capture Read-only disk nothing left behind No network absent, not firewalled No devices no camera, mic, USB No keyboard or screen to capture Read-only disk nothing left behind Your machine your files, network and devices: none of it reachable from inside microVM: a real virtual machine the guest cannot read host memory even if it fully compromises its own kernel The job reads its input, computes, writes one output file; boots in under a second, destroyed when finished

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

Treasury mints within a fixed cap not deployed yet RewardDistributor one reward list per epoch not deployed yet Node operators their payout address burned funds each finalized epoch, up to its budget claims, never more than that epoch’s total unclaimed after a year Treasury mints within a fixed cap not deployed yet RewardDistributor one reward list per epoch not deployed yet Node operators their payout address burned funds each finalized epoch, up to its budget claims, never more than that epoch’s total unclaimed after a year: burned, never spendable

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

Renter rents compute ServiceEscrow holds each job’s price not deployed yet Compute provider runs the job Revenue Safe does not exist yet deposits AXON, signs a hold per job unused balance, and jobs that never ran 80% of a finished job (30% of an honest failure) the rest of the charge Renter rents compute ServiceEscrow holds each job’s price not deployed yet Compute provider runs the job Revenue Safe does not exist yet deposits AXON, signs a hold per job returns unused balance and jobs that never ran 80% of a finished job (30% of an honest failure) the rest of the charge

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

Payer opens a channel once Router any node can route Payee a creator, a provider AxonChannels contract on Sepolia pays off chain, as often as it likes passes it on, minus a small fee locks AXON once settles to the payee Payer opens a channel once Router any node can route Payee a creator, a provider AxonChannels contract on Sepolia pays off chain, as often as it likes passes it on, minus a small fee locks AXON once settles to the payee

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.

Card purchases

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.

Gas

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.

1 · Your node registers once its key binds it to your payout wallet; the site pays gas waits for NodeRegistry 2 · It runs a role storage, relay, gateway, compute, routing… 3 · Witnesses are drawn each 10-minute slot, by the epoch’s randomness; your node cannot choose them 4 · The witnesses test the role a circuit, a probe, a work unit, a signed nonce No receipt for that slot being offline is unpaid, not punished 5 · They countersign the receipt bound to this chain and this deployment kept unsigned until the contracts exist 6 · The aggregator collects them the epoch’s receipts; it has posted a bond 7 · The budget is split and posted per service, capped per node; the reward root goes on chain 8 · A challenge window anyone can dispute the reward root 9 · You claim AXON to your payout address fail or offline pass 1 · Your node registers once its key binds it to your payout wallet; the site pays the gas waits for NodeRegistry 2 · It runs a role storage, relay, gateway, compute… 3 · Witnesses are drawn each 10-minute slot, by the epoch’s randomness; your node cannot choose them 4 · They test the role a circuit, a probe, a work unit or a signed nonce No receipt unpaid, not punished 5 · They countersign the receipt bound to this chain and this deployment kept unsigned until the contracts exist 6 · The aggregator collects them the epoch’s receipts; it has posted a bond 7 · The budget is split and posted per service, capped per node; the reward root goes on chain 8 · A challenge window anyone can dispute the reward root 9 · You claim AXON to your payout address fail pass

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:

Storage 25% Relay 15% Gateway 10% Compute 10% Witness 8% Router 7% MicroVM 5% Probe 4% Validator 4% Watchtower 4% Monitor 3% Mailbox 2.5% Delegate 2.5% Storage 25% Relay 15% Gateway 10% Compute 10% Witness 8% Router 7% MicroVM 5% Probe 4% Validator 4% Watchtower 4% Monitor 3% Mailbox 2.5% Delegate 2.5%

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.

Open one transaction funds locked on-chain Thousands of updates — off-chain each one signed by BOTH sides, each replacing the last instant, free, and invisible to everyone else you always hold the newest signed balance Close one transaction final balances paid out If the other side vanishes or refuses to close honestly: You close alone no cooperation needed Challenge period opens a newer signed state beats an older one Chain pays the honest state cheating costs the cheat Open one transaction, funds locked on-chain Thousands of updates, off-chain each signed by BOTH sides, replacing the last; instant, free and invisible to everyone else; you always hold the newest signed balance Close one transaction, final balances paid out You close alone no cooperation needed Challenge period opens a newer signed state beats an older one Chain pays the honest state cheating costs the cheat If the other side vanishes or refuses to close honestly:

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.

mailbox

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.

delegate

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.

1 · Reader signs the tip in their own wallet 2 · Mailbox holds the message signs nothing 3 · Creator’s node checks it, then signs with the key it holds 4 · Creator’s console review and accept, served by their node the countersigned result is cached back at the mailbox, so a second tip continues from the first accepting costs no transaction fee and touches no blockchain — it is two signatures on a number this site is not in the path: it introduces the two of you and then has nothing to hold reviewing a waiting tip does not consume it, and nothing is accepted until the creator says so 1 · Reader signs the tip in their own wallet 2 · Mailbox holds the message, signs nothing 3 · Creator’s node checks it, then signs with its key 4 · Creator’s console review and accept, served by their node the countersigned result is cached back at the mailbox, so a second tip continues from the first accepting costs no fee and touches no chain: it is two signatures on a number this site is not in the path: it introduces you and then has nothing to hold reviewing a waiting tip does not consume it

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.

Cheat closes on an old state Watchtower notices it is holding a newer one Newer state posted you keep your balance today it alerts; it posts once given a signer What it cannot do send funds anywhere but to you It holds evidence, not authority. Cheat closes on an old state Watchtower notices it is holding a newer one Newer state posted you keep your balance today: it alerts; it posts once given a signer What it cannot do send funds anywhere but to you It holds evidence, not authority.

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.

Noticing a stale closemeasured over 200,000 channels
Getting a transaction minedmeasured on Ethereum mainnet, 30 real transactions
Re-sending it if the fee was too lowmeasured, 30 full recovery cycles
A chain reorganisationstill being observed — see below
Somebody being unavailablea stated commitment, not a measurement

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.

Your latest states signed by both sides Encrypted locally with a key only you hold Split into shards any 6 of 9 rebuild it Spread wide across the network Three of the nine holders can vanish and your backup is still intact. None of them can read it, and none of them can tell it is yours. Your latest states signed by both sides Encrypted locally with a key only you hold Split into shards any 6 of 9 rebuild it Spread wide across the network Three of the nine holders can vanish and your backup is still intact. None of them can read it, and none of them can tell it is yours.
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.

Starting point from 3 unrelated groups Validator signatures checked by us, not taken A block we can prove is real and the balances underneath it If we cannot verify it we refuse — we do not fall back to trusting The three starting points must agree exactly. If they disagree, that is a stop, not a vote. Starting point from 3 unrelated groups Validator signatures checked by us, not taken A block we can prove is real and the balances underneath it If we cannot verify it we refuse; we do not fall back to trusting The three starting points must agree exactly. If they disagree, that is a stop, not a vote.

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.

Alice signs +0.25 Bob signs +1.00 Carol signs +5.00 Dave signs +0.50 Pool aggregates the authorisations it does not hold a balance of its own Recipient draws down 6.75 Alice signs +0.25 Bob signs +1.00 Carol signs +5.00 Dave signs +0.50 Pool adds up the authorisations it holds no balance of its own Recipient draws down 6.75

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.

Operations Safe 2 of 3 signers Contribution-weighted governance votes by contributors and node operators BootstrapProposer ends after 182 days, or at 80% coverage Timelock P waits 2, 7, 14 or 30 days, by the kind of change Guardian Safe 3 of 5 signers; its power expires within a year The contracts reward contracts · Treasury · AXON token OrderDesk · ServiceEscrow proposes while the network bootstraps proposes after bootstrap may cancel or pause executes when the delay is over Operations Safe 2 of 3 signers Governance contribution-weighted: contributors and node operators vote BootstrapProposer ends after 182 days or at 80% coverage Timelock P waits 2, 7, 14 or 30 days, by the kind of change The contracts reward contracts, Treasury, AXON token, OrderDesk, ServiceEscrow Guardian Safe 3 of 5; power expires within a year while bootstrapping after bootstrap executes after the delay may cancel or pause

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

Utility token

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.

Record of verified work

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.

Legal mirror

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.

Owner key today · genesis open AXON Treasury designed · not deployed AxonToken live on Sepolia can mint now mints only for finalized epochs, under a cap designed, not live Owner key today: genesis is open, it can still mint or name a minter AXON Treasury designed, not live: mints only for finalized epochs, under a cap AxonToken live on Sepolia can mint now designed
Designed, not live

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.

Not live

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

Spend

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.

Govern · Designed, not live

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.

Check it

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.

Sepolia bootstrap registry 6 cloud relays the public overlay Cloud server gateway · probe · monitor + validator container worker + microVM compute payment node · watchtower Home lab, 3 machines router · watchtower microVM compute · draining node Site host rabbiit.io · storage node 12 home-lab test relays local only, not public: two small test overlays lists join through join through, outbound from behind NAT joins through Sepolia bootstrap registry 6 cloud relays the public overlay Cloud server gateway · probe monitor + validator worker + microVM payment · watchtower Home lab 3 machines: router, watchtower, microVM, draining node; from behind NAT Site host rabbiit.io storage node 12 test relays home lab, local only, not public lists join join

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.

Cloud watchtower Cloud payment node router · mailbox · delegate Home-lab router Home-lab watchtower 400 · 400 400 · 400 400 · 400 1 test AXON, routed off chain through both routers; each router kept a fee of about 0.001 AXON Cloud watchtower Cloud payment node router · mailbox · delegate Home-lab router Home-lab watchtower 400 · 400 test AXON 400 · 400 test AXON 400 · 400 test AXON 1 test AXON went top to bottom, off chain; each router kept about 0.001 AXON

What is live, and what is not yet

State on 14 October 2026

  • Live

    AXON token, AxonChannels, the bootstrap registry, .axon names

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

1 · Install or build dendritic-node 2 · Configure write config.json, pick your roles 3 · Payout set a payout address 4 · Start it and leave it running On the map within five minutes In its log ‘claiming … each slot’ Registers itself once NodeRegistry is live 1 · Install or build dendritic-node 2 · Configure write config.json, pick your roles 3 · Payout set a payout address 4 · Start it and leave it running On the rabbiit.io map within five minutes In its log ‘claiming … each slot’ Registers itself once NodeRegistry is live

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.

Donated: 0 GB Already used Free

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

Select a platform…
…

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.