Decentralized AI Inference Mesh on Ethereum
every inference. ZK-proven. on-chain.
Website · Docs · X / Twitter · Telegram
ax0n is a permissionless mesh of GPU nodes that serves and verifies AI inference requests — settled on Ethereum.
The core problem with every AI inference provider today is trust. You send a prompt, you get a response. You have no way to verify which model ran, whether the output was tampered with, or whether the provider is even running the model they claim to be. You just trust.
ax0n removes that assumption entirely.
Every request is routed across a decentralized cluster of staked nodes. Every output comes with a cryptographic proof. Every fee settles on-chain. No operator — including ax0n — can serve you a fraudulent result without being detected and slashed.
This is not a hosted AI API with a blockchain marketing wrapper. It is a protocol.
ax0n's architecture is built around three protocol layers that work in sequence for every inference request:
Requests don't go to a fixed server. NeuralRoute scores every node in the mesh by three live signals — stake weight, uptime history, and p95 response latency — and selects the optimal cluster in under 2ms. The routing index is rebuilt every 16 Ethereum blocks, so node scores are always current.
There is no centralized load balancer. The routing logic runs deterministically across validators.
Every inference on ax0n ships with a 288-byte Groth16 proof. ProofCore attests two things:
- The model weights that ran match the on-chain committed hash
- The output is deterministic given the input — no post-hoc modification
The proof is generated in ~120ms and can be verified in under 1ms by anyone. Your AI results are now cryptographically auditable — not by ax0n, but by math.
MeshSync is ax0n's BFT consensus engine running across 10,000+ validators. For every inference, a 256-node quorum is randomly sampled to finalize the result. Finality lands in 1.2 seconds on the optimistic path. Disputed results fall back to ZK verification on-chain.
No single node — or cluster of nodes — can corrupt the result without controlling an economically infeasible share of staked ax0n.
Every inference follows four stages:
- Submit — client broadcasts a signed inference request to the ax0n mempool, specifying model ID, max acceptable latency, and ax0n fee cap. NeuralRoute selects the optimal node cluster within 2ms.
- Execute & Prove — the selected node runs inference locally via the ax0n runtime, then passes the output through ProofCore. A 288-byte Groth16 SNARK is generated attesting to model integrity and output determinism.
- Validator Quorum — a randomly sampled quorum of 256 validators verifies the proof using local verifier keys. The aggregate quorum signature and proof are bundled into the next settlement batch.
- L1 Settlement — batches settle on Ethereum every 512 blocks. Fees are distributed in the same transaction: 78% to node operators, 12% to validators, 10% to the protocol treasury.
Core protocol parameters are set by governance. All changes are subject to a 7-day timelock enforced by the ax0n Governor contract.
| Parameter | Value |
|---|---|
min_node_stake |
1,000 ax0n |
proof_generation_target |
120ms |
slash_window |
256 blocks |
base_fee_rate |
0.3% / inference |
operator_fee_share |
78% |
max_batch_size |
4,096 proofs |
max_model_params |
70B |
validator_quorum_size |
256 |
settlement_frequency |
512 blocks |
node_epoch_length |
2,048 blocks |
governance_timelock |
7 days |
proof_constant_size |
288 bytes |
npm install @ax0n/sdkimport { Ax0nClient } from '@ax0n/sdk';
const client = new Ax0nClient({ apiKey: 'YOUR_KEY' });
// single inference
const result = await client.infer({
model: 'llama-3-70b',
prompt: 'Explain zero-knowledge proofs in one paragraph.',
});
console.log(result.output); // model response
console.log(result.proof); // 288-byte Groth16 proof
console.log(result.txHash); // Ethereum settlement tx// streaming inference
const stream = await client.stream({
model: 'mistral-8x7b',
prompt: 'Write a Rust implementation of a Bloom filter.',
});
for await (const chunk of stream) {
process.stdout.write(chunk.delta);
}Full SDK reference → ax0n.fun/docs
Any GPU owner can join the mesh, serve inferences, and earn ax0n.
# 1. install runtime
curl -sSL https://get.ax0n.fun | bash
# 2. initialize with your operator key
axon-node init --key $AX0N_PRIVATE_KEY
# 3. stake and start
axon-node stake --amount 1000
axon-node startRequirements
| Component | Minimum |
|---|---|
| GPU | NVIDIA RTX 3090 / A10 or better |
| VRAM | 24 GB |
| RAM | 64 GB |
| Storage | 500 GB NVMe |
| Network | 1 Gbps symmetric |
| Stake | 1,000 ax0n |
Nodes earn 78% of every inference fee routed to their cluster. The remaining 22% funds the protocol treasury and validator rewards.
127,000+ nodes are already online.
ax0n is an ERC-20 token on Ethereum mainnet. It is the fee and governance layer of the protocol.
| Function | Detail |
|---|---|
| Inference payment | All inference fees paid in ax0n |
| Node staking | 1,000 ax0n minimum stake per node |
| Governance | On-chain voting on protocol parameters |
| Emission | 2.1% APY distributed to stakers |
| Slashing | Misbehaving nodes lose a portion of stake |
Token Distribution
| Allocation | Share |
|---|---|
| Node operators | 40% |
| Team & advisors | 18% |
| Ecosystem | 25% |
| Treasury | 17% |
61.2% of supply is currently staked.
Total supply: 1B ax0n · Circulating: 423M · Emission APY: 2.1%
| Metric | Value |
|---|---|
| Active nodes | 127,493 |
| Inferences / sec | 2,300,000 |
| Median latency | 0.8ms |
| Protocol TVL | $847M |
| Validators | 10,000+ |
| Proof size | 288 bytes (Groth16) |
| Settlement | Ethereum mainnet, every 512 blocks |
ax0n's security model rests on three properties:
Economic security — Nodes must stake ax0n to participate. Provably misbehaving nodes are slashed. Attacking the network requires controlling enough stake to outweigh the slashing penalty, which is designed to exceed potential attack profit.
Cryptographic security — ProofCore ZK proofs are Groth16 SNARKs. Forging a proof without the correct witness (model weights + input) is computationally infeasible under standard cryptographic assumptions.
Consensus security — MeshSync's random 256-node quorum means an attacker cannot predict or pre-select which validators will finalize a given inference. Bribing or compromising a specific quorum is not possible without compromising a large fraction of the total validator set.
Audit reports → ax0n.fun/docs#audits
Protocol parameters are governed on-chain by ax0n token holders. Proposals go through a 48-hour review window followed by a 72-hour voting period. Passing threshold is 5% quorum with >50% approval.
Governable parameters include routing weights, slashing ratios, emission rate, quorum size, and settlement frequency.
Governance docs → ax0n.fun/docs#governance
| Resource | Link |
|---|---|
| Website | ax0n.fun |
| Documentation | ax0n.fun/docs |
| Node setup | ax0n.fun/nodes |
| X / Twitter | @ax0nfun |
| Telegram | t.me/ax0nportal |
| npm | @ax0n/sdk |
built on Ethereum · secured by ZK · governed on-chain
ax0n ⬡