The first
Proof of Intelligence chain.
DAIT is a sovereign Layer-1 that satisfies all three conjunctive conditions of Proof of Intelligence (PoI): (a) its accepted unit-of-work is a verifiable cognitive computation (inference, finetuning, simulation, reasoning, scientific compute), (b) verification is an adaptive composite of hardware-rooted attestation, cryptographic proofs, statistical sampling, and behavioral checks, and (c) at least one primary economic parameter is a continuous function of network state rather than a constant set at genesis. PoUW satisfies (a) alone. DAIT satisfies all three at mainnet. daitchain is the developer hub: RPC endpoints, block explorer, validator setup, module API docs, and the reference host runtime.
Phase 0 shipped. Devnet next.
Sovereign Layer-1 with nine domain modules wired: tiered staking, multi-vendor hardware-enclave attestation (CPU and GPU confidential-compute modes), proof-of-useful-work commit-reveal, compute marketplace, state channels, on-chain messaging, agent accounts, decentralized data lake, and pseudonymous credentialed identity. WebAssembly contract runtime available. Vote-extension and optimistic-concurrency execution scaffolds in place. Devnet smoke fires May 2026.
| Phase 0 | Repo, Livepaper, public site, nine custom modules implemented and tested. Shipped. |
|---|---|
| Phase 1 | Devnet alpha. 4 validators (Trinity to Quartet). Custom modules live in test. Public RPC and explorer. May 2026. |
| Phase 2 | Public testnet. Real hardware-enclave trust roots. External validator onboarding. External security audit. Bitcoin restaking integration. June 2026. |
| Phase 3 | Mainnet, fair launch. Staking with slashing. State channels live. CLOB. Compute futures. Inter-chain bridges. DAO governance live. July 2026. |
Proof of Intelligence (PoI).
Proof of Intelligence (PoI) is the property of a consensus protocol that satisfies three conditions simultaneously: (a) cognitive unit-of-work - the protocol's accepted unit-of-work is a verifiable cognitive computation (inference, finetuning, simulation, reasoning, or scientific compute) whose execution can be checked by hardware-rooted, cryptographic, or statistical means; (b) adaptive verification - the verification stack is not a single fixed function but composes hardware-rooted attestation, cryptographic proofs, statistical sampling, and behavioral checks, with the verifier function appropriate to a given workload class itself selected adaptively; (c) state-indexed economic parameters - at least one of the protocol's primary economic parameters is a continuous function of network state rather than a constant set at genesis. PoUW satisfies (a). PoI requires all three.
DAIT realizes PoI across four axes. Each of the nine custom modules contributes to one or more.
Axis 1 - Intelligent work
The accepted unit-of-work is a cognitive computation: LLM inference, LoRA/QLoRA finetuning, agent reasoning, tensor-network simulation, zkML proof generation. Realized by x/pouw (cognitive unit-of-work primitive) and x/datalake (enclave-attested storage for intelligence's data).
Axis 2 - Intelligent verification
Verification is an adaptive composite: hardware (multi-vendor TEE), cryptographic (vote-extension force-include, Dilithium from genesis), statistical (proof-of-replication, redundant execution, tensor-train spot decomposition), and behavioral (auditor reputation). Realized by x/tee_attest and x/identity, with x/datalake, x/messaging, and x/agent as secondary contributors.
Axis 3 - Intelligent network adaptation
Primary economic parameters move with network state, per epoch and per block: active-validator cap (sqrt formula), per-block emission (compute-indexed), credit weighting (per-workload-type), standby pool rotation, block time, validator floor. Realized by x/staking_tiers and x/compute_market, fed by x/pouw per-workload weights.
Axis 4 - Intelligent actors
AI agents are first-class economic persons, not wrapped externalities. Quantum-resilient credentials are required from genesis. Realized by x/agent, x/state_channel (off-chain agent negotiation, on-chain finality), and x/messaging (E2E-encrypted agent-to-agent comms with adaptive spam quotas).
PoI is not a new coinage. The idea has been in development for over a decade across multiple iterations (aiscendence.com in 2018, dait.io in 2020); the 2026 convergence of TEE attestation, confidential GPU compute, modular blockchain frameworks, vote-extension consensus, and post-quantum signing is what finally made it shippable. Bitcoin proved money could be public; PoI proves compute can be. See the history and mission on dait.foundation.
Read the formal definition + threat model + module mapping in Livepaper revision 36, section 3 or the PoI explainer on dait.foundation.
The technology layers.
DAIT is a sovereign appchain engineered to satisfy Proof of Intelligence (PoI). The base layer (state machine, networking, consensus, inter-chain communication) comes from a maintained modular blockchain framework. The differentiating layer (nine custom domain modules) is where the four PoI axes are realized. Each row below names the PoI axis the layer most directly serves.
| Consensus (Axis 2, 3) | Byzantine fault tolerant consensus engine, single-slot finality, vote-extension support; 2/3+ stake-weighted commit per block. Vote-extension is the cryptographic force-include channel that makes adaptive verification (axis 2) censorship-resistant; per-epoch active-validator cap is the axis-3 state-indexed economic parameter. |
|---|---|
| Networking (Axis 4) | Authenticated and encrypted peer protocol over TCP (ed25519 station-to-station handshake, ChaCha20-Poly1305 AEAD); multiplexed channels for consensus, mempool gossip, block sync, state sync. Carries agent-to-agent traffic for axis-4 actors. |
| State machine (Axis 4) | Modular blockchain framework with smart-account substrate (every account can carry programmable authentication logic). The substrate is what lets x/agent treat AI agents as first-class economic persons (axis 4). |
| Execution (Axis 1) | Dual virtual machine: optimistic-concurrency parallel EVM (full opcode compatibility) and a sandboxed WebAssembly contract runtime. The execution layer carries axis-1 cognitive workload metadata: PoUW receipts, attestation references, marketplace fills. |
| State commit (Axis 2) | Authenticated Merkle tree (IAVL) backed by an in-memory write-ahead-log layer over a log-structured key-value store; v2 lands Q4 2026. Merkle commitments anchor axis-2 statistical and cryptographic verification proofs. |
| Cross-chain (Axis 3) | Inter-Blockchain Communication v10 for trust-minimized asset and message bridging. Lets axis-3 economic parameters absorb external liquidity signals (e.g. Bitcoin restaking, bridged stables). |
| Custom modules (all 4 axes) | Nine DAIT specific domain modules realize the four PoI axes (see Modules section below). |
The execution layer is a true parallel EVM. Transactions in a block run speculatively in parallel, with read-set and write-set tracking; conflicting transactions re-execute in serial dependency order against the post-conflict state. Empirically the mean conflict rate on production-shaped workloads is 5-15%, leaving 85-95% of transactions executing fully in parallel. The result is the same final state as strict serial execution, with throughput scaling almost linearly with cores. This matters for PoI because axis-1 cognitive-work receipts and axis-3 state-indexed parameter recalculations both land on the execution layer in volume.
Validator and host setup.
Three roles, three setup paths. All require staked DAIT once mainnet launches. None are gated by application or KYC.
Validator
Propose blocks. Earn 30 percent of block rewards weighted by your delegated PoUW credits. Hardware: 16 vCPU, 64-128 GB RAM, 4 TB NVMe, sub-150ms p99 to other validators. Self-bond 100,000 DAIT minimum.
$ daitd init my-validator --chain-id dait_4090-1
$ daitd start
$ daitd tx staking create-validator \
--moniker my-validator \
--amount 100000000000udait \
--commission-rate 0.05
Node (compute host)
Host AI inference inside a hardware-attested enclave. Earn 60 percent of block rewards proportional to verified work. Hardware: any GPU with confidential-compute mode (the leading data-center GPU vendor's H100 / H200 / B200 product lines), or a 5th-generation server CPU with confidential-mode support. Stake 3,690 DAIT per registered GPU.
$ dait-host init --tee-kind gpu-cc $ dait-host register --gpu-uuid GPU-xxxx $ dait-host serve --models llama3.1-8b,qwen2.5-7b
Tenant (rent compute)
Submit AI jobs to the network. Open a state channel for high-frequency inference. Pay only for verified, attested execution.
$ dait-cli deploy job.sdl --price-ceiling 50udait $ dait-cli channel open host123 --escrow 1000udait --hours 24 $ dait-cli infer --model llama3.1-8b --prompt "..."
Detailed runbooks at forge.dait.io/dait/docs (coming Phase 1).
RPC and gRPC endpoints.
Public testnet endpoints will be available at Phase 1. EVM-compatible JSON-RPC plus standard appchain-framework REST and gRPC.
JSON-RPC (EVM)
https://rpc.daitchain.io
EVM-compatible. Use with MetaMask, ethers, viem, web3.js, web3.py. ChainID 4090 testnet, 1 mainnet.
Framework REST
https://api.daitchain.io
Standard appchain-framework REST. Query bank balances, staking state, governance proposals, custom DAIT module state.
Framework gRPC
grpc.daitchain.io:9090
For high-throughput indexers and bot frameworks. Includes DAIT custom module proto definitions.
WebSocket events
wss://rpc.daitchain.io/websocket
Subscribe to NewBlock, Tx events. EVM-compatible eth_subscribe.
Consensus RPC
https://rpc.daitchain.io:26657
Direct consensus-engine RPC. Block, validator, network info, raw tx submission.
State sync
https://rpc.daitchain.io:26657 (statesync)
Fast new-validator catch-up. Snapshot interval 6,000 blocks.
Block explorer.
The DAIT block explorer goes live with Phase 1 devnet alpha in May 2026. It is a Ping.pub fork with DAIT custom module support: PoUW receipts, attestation verification status, compute marketplace orders, state channel state, agent account lineage.
Currently shows "coming Phase 1". Bookmark and check back.
The nine DAIT specific modules.
DAIT extends the appchain framework with nine custom domain modules. Each card is tagged with the PoI axis (1-4) it primarily realizes; several modules also contribute to a secondary axis. Full source at forge.dait.io/dait.
x/staking_tiers Axis 3
Six-tier staking with progressively higher locks. User, Heavy, Node, Supernode, Validator, Oracle. Each tier is 10x the previous, anchored at 100 DAIT. Tier-gated rights and per-tier slashing rates. 14-day unbonding cliff. Scales operator influence to deployed intelligence (axis 3, secondary axis 4).
x/tee_attest Axis 2
On-chain hardware-enclave attestation verification across three silicon-vendor confidential-compute modes (one GPU vendor, two CPU vendors). Quote bodies stored off-chain. Result + 32-byte content hash on-chain. Vote-extension force-include for censorship resistance. The hardware-rooted leg of axis-2 adaptive verification.
x/pouw Axis 1
Proof-of-Useful-Work credit accrual. Token-weighted, attestation-gated, audit-discounted. Soulbound credits with 14-day half-life. Commit-reveal receipts with 9-block reveal window. 60/30/6/3/1 emission split (hosts/validators/treasury/insurance/burn). The cognitive unit-of-work primitive (axis 1); per-workload weights drive axis-3 adaptation.
x/compute_market Axis 3
Reverse Dutch auction marketplace. Five cooperating sub-modules: deployment, market, provider, audit, escrow. Block-by-block streaming escrow with auto-close on insufficient funds. 60% fee burn, 40% to community pool. The reverse-Dutch auction is the axis-3 adaptive matching mechanism (secondary axis 4, since agents are first-class buyers).
x/state_channel Axis 4
Off-chain compute sessions with turn-taking forced-move dispute protocol. Open with one transaction, transact off-chain, close with one transaction. 24-hour challenge window. Receipts merkleized into channel state. Carries off-chain agent negotiation with on-chain finality (axis 4).
x/messaging Axis 4
Wallet-to-wallet encrypted messaging. Public keys, contact graphs, group state, spam-tier quotas on chain. Bodies travel via peer-to-peer relay with double-ratchet end-to-end encryption (one-to-one) and Messaging Layer Security RFC 9420 (groups). E2E-encrypted agent-to-agent comms (axis 4); per-account spam quotas adapt with reputation (axis 2).
x/agent Axis 4 PQ from genesis
AI agents as first-class economic accounts (axis 4). Built on smart-account substrate. Operator/hot-key two-key model with rolling-24h spend policy. Recursive child agents (depth 3). Multisig recovery-guard with per-signer cryptographic verification. Quantum-resilient by default: every agent registers a NIST FIPS 204 / ML-DSA-65 (CRYSTALS-Dilithium Mode 3) hot key at genesis-day; legacy secp256k1-only agents fail authentication. Dilithium-required-from-genesis is the cryptographic leg of axis-2 verification for agent action.
x/datalake Axis 1
Industrial-grade decentralized storage. Storage providers run inside hardware-attested enclaves. Reed-Solomon erasure coding (10+4 default, 1.4x overhead vs 3x replication). Geo-distributed replication, governance-tunable factor. SLA-graded tiers: hot (<10ms), warm (<1s), cold (archival). Continuous proof-of-replication challenges signed inside enclaves (axis-2 statistical verification). Streaming pay-by-byte-month via channel-style escrow. Integrates with x/compute_market for "lease requires this dataset" semantics. Holds the data intelligence runs on (axis 1).
x/identity Axis 2
Pseudonymous credentialed identity with zero-knowledge attribute proofs. Operators prove "SOC 2 Type II", "EU jurisdiction", "GDPR-compliant", "accredited investor" without revealing legal entity. Issuer market: accredited auditors issue ZK credentials in DAIT. Selective disclosure for regulated workloads (healthcare, finance, defense). Per-credential revocation. W3C Verifiable Credentials compatible. ZK selective disclosure is the behavioral/credentialed leg of axis-2 verification for regulated intelligence (secondary axis 4). Distinct from x/agent (which handles bot identity).
Throughput and latency budget.
Targets per phase. The chain is the bottleneck only at Phase 1; once state channels and DAG mempool ship, compute throughput becomes a property of host GPU memory bandwidth, not block time.
| Metric | Phase 1 (devnet) | Phase 2 (testnet) | Phase 3 (mainnet) |
|---|---|---|---|
| Block time | 1000 ms target | 1000 ms then 500 ms | 500 ms |
| Block gas limit | 99M | 99M | 99M |
| Active validators | 3 → 4 → ~12 | dynamic (floor 100, scales with use) | dynamic (ceiling 256; standby 4-10x active) |
| L1 sustained TPS | 5-10k | 30-50k | 30-50k |
| L1 peak TPS | 28k | 80k | 80k |
| User AI calls/sec | bounded by L1 | bounded by L1 | unbounded (channels) |
| Finality | Sub-second BFT (single-slot, no probabilistic depth-of-confirmation) | ||
For deeper performance and consensus detail, see the Livepaper performance section and block production.
Building the chain.
Engineers welcome. Validators welcome. Hosts welcome. Pseudonyms welcome.
Contact form · topic = "Run a compute host" or "Run a validator"
For governance, see dait.foundation. For the chain itself, see dait.io.