Whisper network

Compute
without a
coordinator.

A trustless AI agent compute market on Gensyn AXL. Providers join an encrypted P2P mesh; jobs are auctioned and executed with gossip-replicated ledger state — no central broker. Identity maps through ENS (axl.eth on Sepolia); transport and signing ride AXL.

Clone on GitHub Run locally axl.eth →

Start a node

krishnan74 / whisper-network

Before you run

Python 3.11+ — dependencies listed in repo requirements.txt (e.g. cryptography, flask).
AXL binary at axl/node — pre-built static Linux x86-64 in the repo (used by run_local.sh).
openssl — for key generation (invoked automatically by run_local.sh).
Optional: ENS — set JUSTANAME_API_KEY in .env; run_local.sh loads it.
Optional: Ollama — real inference; otherwise providers fall back to keyword search. For six parallel callers use OLLAMA_NUM_PARALLEL=6 ollama serve.
Optional: Docker — multi-provider setup via repo docker-compose.yml.

Run the mesh · default (6 providers)

Clone the repo and enter it (creates isolated env via ./run_local.sh).
(Optional) Start Ollama with enough parallelism so all shards can answer at once — see snippet in the Quickstart box.
(Optional) Append JUSTANAME_API_KEY=… to .env for ENS subname registration on startup.
Start all provider nodes: FAST_MODE=1 ./run_local.sh — boots AXL staggered (~1.5 s spacing), gossip, auctions, and Whisper; FAST mode uses shorter leases for quicker recovery demos.
Open the dashboard in another terminal: .venv/bin/python -m demo.webui. Browse to http://localhost:5000 (default provider HTTP debug ports are 8888–8893—the UI polls them).
Sanity-check: ./demo/verify.sh (five automated checks incl. fault path). Full scripted demo: ./demo/judge_demo.sh "neural network training".

# 0. (Optional) Real LLM inference
ollama pull llama3.2
OLLAMA_NUM_PARALLEL=6 ollama serve &

# 0b. (Optional) ENS self-registration via JustaName (Sepolia)
echo "JUSTANAME_API_KEY=your_key_here" >> .env

# 1. Start providers (6 nodes, FAST_MODE = short leases / quick rescue)
FAST_MODE=1 ./run_local.sh

# 2. Web UI (new terminal at repo root)
.venv/bin/python -m demo.webui
# → http://localhost:5000

# 3. Automated checks
./demo/verify.sh

# 4. One-button demo: converge → submit → kill 3 providers → recover
./demo/judge_demo.sh "neural network training"

Fewer providers

Pass --count N to run_local.sh. When you change N, align the Web UI’s port slice so it only polls nodes you actually started — e.g. three providers on ports 8888–8890:

FAST_MODE=1 ./run_local.sh --count 3
.venv/bin/python -m demo.webui --nodes 8888-8890

Submit over AXL only

Jobs can be injected through the local AXL HTTP bridge (no debug HTTP on the critical path). Point --axl at the first node’s bridge (default 9002), from the repo root with the venv active:

.venv/bin/python -m demo.submit_p2p "attention" --axl http://localhost:9002

Interactive kill/rescue window: start with EXEC_DELAY=15 FAST_MODE=1 ./run_local.sh so tasks stay in_progress long enough to hit Kill in the UI.

ENS · identity layer

Sepolia · axl.eth

Human-readable names anchor machine identity. Whisper stores AXL peer material and provider metadata (capabilities, pricing, shard) in ENS text records so peers resolve each other without a centralized directory.

The Whisper namespace on Sepolia is axl.eth. Inspect the parent and every issued subname on ENS:

axl.eth on ENSBrowse subnames

Name hierarchy (example pattern)

Parent — root name delegates subnames (e.g. a project parent like notdocker.eth in generic tutorials, or the live Whisper parent axl.eth).
Node subname — register under the parent (e.g. node.axl.eth or node1.notdocker.eth in sample configs).
Nested subnames— use the node name as parent for finer identities (e.g. agent1.node.axl.eth, agent2.node.axl.eth, …) so each agent retains a stable ENS path tied to keys and policy.

AXL · network layer

Read the docs →

Agent eXchange Layer (AXL) is Gensyn’s peer-to-peer node: encrypted transport, outbound NAT-friendly meshing, and a local HTTP bridge (typically localhost:9002). Whisper treats that node as authoritative for who is reachable, routes gossip and auctions across it, and signs ledger updates with the same ed25519 material AXL exposes.

Transport

Jobs, bids, awards, and results move as encrypted AXL traffic — Whisper does not bolt on a second wire protocol.

Identity

Each provider's AXL ed25519 key is cluster identity and signing key for gossip ledger updates.

Topology

`GET /topology` tracks the live mesh so membership mirrors who is actually routable.

Local bridge

Any stack can POST `/send`, poll `/recv`, and compose higher-level auctions on top.

No coordinator bottleneck.

Job state replicas across providers in real time. When a node dies, gossip detects it, leases expire, survivors reclaim work — without a central API saving you.

ENS names, AXL paths.

`axl.eth` subnames advertise who you are off-chain and on ENS; AXL wires the bytes. Same separation as docs: naming vs pipe.

Auctions over the mesh.

Bid requests broadcast to alive peers (~400 ms auction window), awards travel signed over AXL, execution starts immediately — not after a polling loop.

Fault tolerance

50%

Lose half the cluster — the mesh finishes in-flight inference after fast-suspect failure detection (~9 s rescue in FAST_MODE demos).

Surviving quorum

3/6

Quorum guards shard affinity and threshold decryption. Survivors subtract confirmed-dead peers from effective cluster size so orphaned leases get claimed legally.

Stack primitives

From the repo README

Ledger

Lease-based ownership, version-vector merges, ed25519-signed gossip, optional Shamir threshold encryption per task.

Membership

SWIM-lite heartbeats plus AXL-triggered fast-suspect when the mesh drops a peer.

Runtime

Price auction winner claims immediately; 5 s scan fallback; shard-affinity prefers home shards before rescue.

ENS records

`axl.peer_id`, capabilities, `price_axl`, `shard_id` — mirrored from what providers publish at startup.

whisper

GitHub axl.eth Subnames AXL docs

● alive● auction● dead

Computewithout acoordinator.