A drop-in OpenAI API on a sovereign L1: every answer carries a proof block anchored on-chain, a sample is re-audited by an LLM-judge committee, and a cheating miner is slashed — automatically.
# any OpenAI client — only base_url changes client = OpenAI(base_url="https://api.dendranetwork.com/v1") r = client.chat.completions.create(model="dendra-network", …) r.model_extra["dendra"] # the proof block { "job_id": "job_…", // on-chain anchor "committee": ["m-…"], // VRF-drawn "audit_state": "pending", // audit lands later, on The Proof "cost_udndr": 650, "verify": { "query": "dendrad query jobs get-job job_…" } }
Point any OpenAI-compatible client at the gateway. Every answer settles on-chain; a VRF-drawn sample is re-audited afterwards. The chain never sees your content.
The client encrypts the prompt to the miner's key and sends it via the OpenAI-compatible gateway. The chain sees only a fee and a job id.
The fee is escrowed in a module account. An on-chain VRF beacon fixes the assignment seed, so the requester can't grind the job id to pick a complicit miner. The pool the draw reads is not yet frozen (ADR-037): registering a fresh identity after the seed is public still buys a seat.
The assigned miner runs the model on its GPU and is paid optimistically. Plaintext exists only in RAM during compute, behind sealed-memory and egress guards.
A random share of jobs is re-checked by a fresh, VRF-selected committee that judges the answer with an LLM. A wrong — or silent — miner is slashed hard.
It's the OpenAI API — change base_url and every response carries a proof block your code can act on. Settlement is on-chain for every answer; the audit lands on a VRF-drawn sample (currently 50% — a governable parameter).
A slash is invisible inside a normal chat — so it goes on the table instead. The explorer below reads the chain and lists audited jobs and real slashes, live. It is the one thing a closed model cannot show you.
Every record here is a real, replayable on-chain event, read live from the network — audited jobs and the slashes that back every answer.
Every record here is independently replayable: pull the chain, re-run the audit, get the same verdict.
The client isn't a person reading a chat — it's a program about to act. Dendra gives that program a proof to check before it trusts, backed by stake it can watch get slashed.
An agent that spends, signs, or triggers workflows shouldn't act on an answer it can't check. Read the dendra block, gate the action on the audit state, and let slashing price dishonesty out.
Feed downstream protocols answers that settle on-chain and can be re-audited by a committee. The verdict is public and replayable — an economic backstop your feed can reference in code.
Classification, extraction, moderation at volume — spot-audited by the network itself, so output quality is enforced by economics rather than spot-checks you have to run yourself.
Prompts are end-to-end encrypted to the serving GPU — plaintext never touches the chain, the relay, or logs. A hardware-enclave tier for regulated data is planned and does not exist: no code path implements it, and nothing on the consumer path should be read as an enclave guarantee.
A small group of early design partners is being onboarded while the network hardens. Enterprise SLAs and an external audit ship with the production network. What is ready today is stated plainly on this page and readable live on the explorer — nothing needs to be taken on faith.
The chat is the network's showcase: every reply carries its verifiability panel — job id, committee, real cost, and the exact command to re-check it on-chain. Capacity varies with the network.
End-to-end encrypted client↔miner (X25519 ECDH + AES-256-GCM) — nothing in clear at the relay or on-chain. On consumer GPUs the miner decrypts in RAM to compute, guarded by sealed memory, egress and disk guards and slashing. Software attestation ships in the code but is not enforced on the public network, so it does not count as a protection in force today.
The intended design is that on datacenter GPUs, inference would run inside a hardware secure enclave for cryptographic confidentiality, aimed at regulated workloads. It is not implemented and cannot be selected. There is no hardware root of trust anywhere in the current code, and every job on the network runs on the standard path described on the left.
Proof-of-Work burns gigawatts on meaningless hashes. Dendra secures a market for what people actually want from GPUs today: AI inference — done privately, verified statistically, and paid for under an honest-stake majority.
Miners are GPU owners running a real LLM. The work the chain rewards is verified inference for paying clients — not hashing. A consumer GPU is enough to take part.
Prompts are end-to-end encrypted client↔miner (X25519 + AES-256-GCM). The relay and the chain only ever see hashes, embeddings and metadata — never your content.
Most jobs settle instantly. A random sample is re-checked by a fresh, VRF-selected committee that judges the answer with an LLM — and a wrong answer is slashed hard. Cheating is made loss-making, not merely discouraged.
$DNDR is what you pay for inference and what miners earn. A hard 10M cap, with every reward released from a pre-allocated Reserve — never minted into existence.
These five balances are in the genesis file itself — download it, add them up.
The explorer reads the resulting supply back off the chain.
Base unit udndr · 1 DNDR = 1,000,000 udndr. The cap does not rest on a policy anyone could change: the standard mint module is absent from the chain binary, so no code path can create a coin. Check it against the running network on the explorer.
Dendra is open source. Spin up a node on a consumer GPU, send a real prompt through the network, and watch it settle on-chain. Serving a job earns the client's fee minus the protocol cut — honest work is paid, lazy or wrong work is slashed. The payment is placed in escrow at settlement and released at audit finality; while the network has a single VRF contributor the audit draw is deferred, so the escrow accumulates instead of settling. Held and dated on-chain, not forfeited: it drains once a second operator anchors a VRF key.
No curl … | sh: piping a URL into a shell runs whatever the server returns, unread and unverifiable. Read deploy/join.sh first — it is the same file you are about to run.
A real network with the full inference economy on-chain — every layer below is live and open source.
Scope, and where it was measured. The slashing path above was exercised on the project's own development network: 2 validators (the larger holding ~65% of the voting power), 2 VRF contributors, and a single slash event — on a miner run deliberately to cheat, with no honest miner penalized across 43 audited jobs. That is a working mechanism on a small network, not a distributed one. The public network runs from a fresh genesis and inherits none of that history: one validator, no registered miner, and audit draws deferred until a second VRF contributor anchors a key. Read the current state from the chain, not from this page.
Build the hard part first — a chain that provably slashes cheaters. Then open it, grow the GPU community, and take verifiable AI to business. Here's the path, honestly.
On-chain escrow, VRF assignment, optimistic verification with an LLM judge, replay-safe settlement, real-coin emission, bonds and burn — with hard slashing that has fired on-chain and no honest miner penalized so far.
A public testnet anyone can join, a live on-chain “Proof” feed, an OpenAI-compatible chat, a regex prefilter at the gateway (a floor, not a content guarantee), and monetization with buy & burn on real revenue.
One-click miners for community GPU owners, throughput measured across independent operators, and a broad, cross-hardware operator set.
A hardware-isolated privacy tier, an external audit and SLAs, and auditable, slashable inference for companies that must prove their AI. Image generation joins here, behind the same verification bar.
Run by many independent operators on separate hardware, secured by everything above — shipped when it's right, not before.