arknet
Decentralized AI inference. One binary. Fair launch.

Website · Docs · Tokenomics · Explorer · Forum

Anyone with a computer earns ARK for serving AI models. Any developer queries AI through a peer-to-peer mesh — install the SDK, connect, infer.

Use the network (Python):

from arknet_sdk import Wallet, Client

wallet = Wallet.create()
wallet.save()

session = wallet.create_session(spending_limit=100_000_000, expires_secs=3600)
client = Client.connect(session=session)
response = client.infer(
    model="Qwen/Qwen3-0.6B-Q8_0",
    prompt="Hello from arknet",
    max_tokens=64,
)

Use the network (Rust):

use std::time::Duration;
use arknet_sdk::{Client, ConnectOptions, InferRequest, wallet::Wallet, session::SessionKey};

let wallet = Wallet::create();
let session = SessionKey::create(&wallet, 100_000_000, Duration::from_secs(3600))?;
let client = Client::connect(ConnectOptions {
    session: Some(session),
    ..Default::default()
}).await?;
let response = client.infer(InferRequest {
    model: "Qwen/Qwen3-0.6B-Q8_0".into(),
    prompt: "Hello from arknet".into(),
    max_tokens: 64,
    ..Default::default()
}).await?;

Your wallet address is your identity. The SDK joins the p2p mesh as a lightweight libp2p peer, discovers compute nodes via gossip, and sends inference requests directly over Noise-encrypted channels. No HTTP. No gateway. No middleman.

How it works

┌──────────┐  bootstrap  ┌───────────┐  gossip   ┌──────────┐
│  User /  │ ──────────► │ Validator │ ◄──────── │ Compute  │
│  SDK     │             │ (consensus│  "I have  │  (runs   │
│          │             │  + relay) │  model X" │  model)  │
│          │ ◄──────────────────────────────────► │          │
│          │    direct p2p (Noise-encrypted)      │          │
└──────────┘    via relay, then hole-punch        └──────────┘
                     ┌───────────┐
                     │ Verifier  │
                     │ (checks   │
                     │  output)  │
                     └───────────┘

1. Compute nodes gossip their loaded models on the arknet/pool/offer/1 topic (heartbeat every 60s).
2. SDK bootstraps from seed validators, subscribes to gossip, and discovers which compute nodes have which models.
3. SDK connects to the compute node through the validator relay (libp2p circuit relay), then DCUtR hole-punches a direct connection.
4. Inference travels directly between the SDK and compute node — the validator never sees the prompt.
5. Verifier re-executes 5% of jobs deterministically — cheaters get slashed.
6. Validator finalizes the receipt on L1, emission mints ARK.

Two node types: Validator (consensus + relay + seed) and Compute (inference + gossip announce). That's it.

As a developer

Install the SDK, create a wallet, create a session key, connect, infer. During the bootstrap period (first 6 months or 100 validators), inference is free.

pip install arknet-sdk    # or: cargo add arknet-sdk

from arknet_sdk import Wallet, Client

wallet = Wallet.create()
wallet.save()
session = wallet.create_session(spending_limit=100_000_000, expires_secs=3600)
client = Client.connect(session=session)

response = client.infer(
    model="Qwen/Qwen3-0.6B-Q8_0",
    prompt="Hello from arknet",
    max_tokens=64,
)
print(response.text)

Session keys authorize bounded spending from your wallet. Your main key signs a DelegationCert granting an ephemeral session key a spending_limit and expiry. Inference requests are signed by the session key — if compromised, damage is bounded.

TypeScript SDK (npm install arknet-sdk) exists but has not yet been updated for the p2p architecture. Coming soon.

As a node operator

Run the binary, pick your role, earn ARK.

curl -fsSL https://arknet.arkengel.com/install.sh | sh
arknet init
arknet start --role compute   # or: --role validator

See the full Node Operator Guide for step-by-step validator and compute setup.

Ports

Discovery

The SDK discovers compute nodes through the gossip mesh:

1. Load seed validator addresses from seeds.json (hardcoded fallback in SDK binary)
2. Bootstrap into the libp2p mesh via a seed validator
3. Subscribe to arknet/pool/offer/1 — receive PoolOffer messages from compute nodes
4. Connect to a compute node offering the requested model (relay, then hole-punch)

No HTTP endpoints. No gateway. Everything is libp2p.

Wallet

Ed25519 keypair. 64-byte file at ~/.arknet/wallet.key. Address = blake3(pubkey)[0..20].

from arknet_sdk import Wallet
wallet = Wallet.create()
wallet.save()
print(wallet.address)

Or: arknet wallet create

The same wallet file works across Python, Rust, and the CLI.

CLI

# Wallet
arknet wallet create
arknet wallet balance
arknet wallet send --to 0x... --amount 1000000000

# Staking
arknet wallet stake --role compute --amount 50000000000000
arknet wallet unstake --role compute --amount 50000000000000
arknet wallet complete-unbond --role compute --unbond-id 1
arknet wallet redelegate --role compute --to-node 0x... --amount 50000000000000

# Governance
arknet governance propose --title "Add Llama 4" --body @proposal.md
arknet governance vote --proposal 1 --choice yes

# TEE
arknet tee keygen
arknet tee register --platform intel-tdx --quote-file quote.bin

Why arknet?

Reward split

Every verified inference job mints ARK:

Privacy — three tiers

Fair launch

No premine. No investors. No team allocation. No airdrop. Every ARK is minted against verified inference work after genesis. The maintainer holds zero tokens at launch.

Bootstrap period (first 6 months or until 100 unique validators): inference is free, min_stake = 0, anyone can join. Compute nodes earn ARK from block emission for serving free requests.

Genesis models

10 models ship at genesis — from Raspberry Pi to server:

Full list with SHA256 digests: models

Status

License

Apache-2.0