Development Roadmap
The inference network roadmap covers inference services, GPU nodes, Logprob verification, data privacy, and scaling. A separate four-stage roadmap covers cryptographic verification with SLP.
Inference Network
Inference Network Roadmap
Phase 0 · Current Phase
Core Network
- Launch a dedicated inference chain with USDC payments, node service bonds and a Hyperlane asset bridge for task settlement, deposits and withdrawals.
- Open up model registration and GPU node onboarding. Support dense models for inference and verification, with defined model versions, serving precision, verification rules and pricing.
- Assign tasks using future block randomness after fixing the candidate list and selection weights, so anyone can independently verify Worker and Verifier selection.
- Deliver streamed outputs before verification and settlement are complete. Use signatures and cumulative commitments to bind each chunk to the final output.
- Implement log-probability (Logprob) verification across all generated tokens, with Verifier commit–reveal and an independent challenge process.
- Store task materials with the Builders assigned to each task. Support retrieval from multiple nodes, fault recovery and applicable refunds for timeouts, failed verification and unavailable materials.
- Complete testing and deployment in stages: localnet, shared testnet and mainnet. Launch with all nodes starting from the same baseline performance score, and with governance-managed Validator and Builder sets.
Phase 1 · Next
Dynamic Performance and Service Reliability
- Introduce performance scores grouped by model, serving precision and task size, giving consistently reliable nodes more assignment opportunities.
- Combine recent and long-term performance, define initial scores for new nodes and rules for score decay and for nodes with limited data, and ensure that scoring upgrades do not retroactively change historical tasks.
- Define when an order has enough competition to count toward performance scores. Set rules for models with few competing nodes and test for manipulation through self-generated orders, multiple identities and collusion.
- Calculate service-speed scores from on-chain records. Publish the timing method and explain how network transfers and delays in on-chain confirmation affect the scores.
- Publish verification calibration tools for real models across different hardware, inference engines and batching workloads, measuring false rejections and missed violations.
- Adapt inference engines to capture expert-routing records for mixture-of-experts (MoE) models, and verify routing alongside model outputs.
- Improve stream resumption and recovery from node failures. Publish onboarding documentation for independent operators, along with model performance and cost reports.
- Add optional encryption for inputs, outputs and verification materials so Builders can store, relay and check data integrity without reading plaintext.
Phase 2 · Planned
Data Availability, Privacy and Smart Contracts
- Introduce erasure coding with evidence shards distributed across Builders, reducing redundant storage and supporting recovery from multiple nodes.
- Introduce storage certificates, random retrieval audits and a challenge process for unavailable data. Start repairs before the number of available shards falls below the recovery threshold, and define retention periods and service fees.
- Deliver decryption keys according to task roles and verification stages: input keys after Worker selection, keys for verification materials after Verifier selection, and keys for Worker comparison values during the reveal stage.
- Support encrypted streaming, stream resumption and integrity checks after decryption. Provide key delivery for dispute review and define what happens when key holders go offline.
- Provide smart contract interfaces for inference calls, multi-step workflows, result queries and revenue allocation, with handling for timeouts and duplicate requests.
Phase 3 · Planned
Economic Mechanisms and Open Consensus
- Gradually open Validator admission so independent operators can participate in consensus, and support updates to the Validator set.
- Introduce delegation and undelegation, with rules for reward distribution, withdrawal waiting periods and penalties.
- Upgrade staking and exit procedures while preserving outstanding task, challenge and storage obligations during migration and fund release.
- Develop a service-reward proposal with defined funding sources, eligibility requirements and safeguards against manipulation. Enable it through an approved protocol upgrade.
- Expand on-chain parameter governance with public proposals, voting, activation times and adjustment limits, preserving the rules for tasks already accepted.
- Improve bridge signer updates, key rotation and cross-chain recovery. Obtain independent security audits of economic upgrades, governance permissions and asset bridges.
Phase 4 · Planned
Open Builders and Batch Submission
- Open up Builder registration with a bond requirement, and evaluate nodes using verifiable service and violation records.
- Implement Builder rotation, transferring responsibility for coordinating unsettled tasks and fulfilling outstanding storage obligations.
- Create a unified intake mechanism that removes duplicates and applies a consistent ordering to task requests, node participation submissions and signed materials. Allow omitted records to be resubmitted.
- Introduce batch execution and on-chain submission while preserving per-task verification, fee details and accountability. Settle funds after the main chain verifies the results.
- Limit batch sizes and waiting times while respecting each task’s deadline.
- Support recovery from interrupted handovers and failed batches, checking which records have already been processed to prevent duplicate execution and payment.
Phase 5 · Planned
Single-Chain Scaling
- Optimize batch verification, fund reconciliation, caching and state access to reduce repeated per-task work.
- Improve indexing of tasks and historical records for faster status queries.
- Process independent tasks in parallel while maintaining consistent account balances and fund records.
- Expand shard transfers, retrieval from multiple sources and data repair to reduce repeated transfers of evidence.
- Monitor task and data-processing backlogs, jointly tuning block intervals, batch sizes and waiting times.
- Publish sustained-load and fault-injection test results covering latency, failure rates and per-task costs. Measure throughput as the number of tasks that complete verification and settlement per unit of time.
Cryptographic Verification
Cryptographic Verification Roadmap (SLP)
SLP (Sampled Layerwise Proofs) uses cryptographic commitments to fix computation records before randomly selecting layer groups to prove, reducing the cost of proving LLM inference. Models that follow defined integer fixed-point rules use cryptographic computation proofs; floating-point services use commitments and numerical audits with calibrated tolerances. The two paths are developed separately.
SLP Stage 0 · Complete
Proof of Concept
- Completed end-to-end experiments on GPT-2, TinyLlama-1.1B and Llama-2-70B, demonstrating sampled layerwise proofs on real models.
- Implemented commit-then-sample verification, with Verifiers independently selecting layer groups and always checking the input and output groups.
- Implemented streaming weight commitments and sampled proving for 70B on a CPU host with 2 TB of RAM.
- Implemented multi-request proof packing, evaluated quantized-model fidelity and identified model versions with weight and scale digests.
- Tested grinding attacks against Fiat–Shamir sampling and rejected all seven adversarial negative test cases. Designed a proving workflow using future beacon randomness.
Measured Results
- GPT-2 · Laptop CPU: Committing 27 boundaries and proving 5 of 27 layer groups took 28 seconds; verification took 0.16 seconds.
- TinyLlama-1.1B · RTX 4090 Inference, CPU Proving: Packing 12 requests into one proof reduced proving cost by about a factor of 6.5 compared with generating separate proofs.
- Llama-2-70B · 256 Threads, 2 TB CPU Host: Committing 163 boundaries and proving five layer groups took 21 minutes. The proof was 4.34 MiB; verification without model weights took 46 seconds. These are sampled-proof measurements, not full-proof or GPU-proving results. Read the full proof-of-concept report
SLP Stage 1 · Next
Security Hardening and Testnet MVP
- Complete the registration-to-settlement workflow for models with 1–3 billion parameters, including inference, commitments, proof generation and verification. Bind the model, input, output and proof to the same request.
- Integrate a reference string generated through a public setup ceremony, together with a live randomness beacon, with handling for missing or delayed beacon values and invalid beacon proofs.
- Fix a single commitment for each request before randomness is revealed, preventing resampling through replaced materials or repeated submissions to obtain a favorable sample.
- Bind returned tokens to the decoding parameters and sampling randomness, including temperature-based sampling.
- Harden range, rounding and overflow checks for integer fixed-point arithmetic. Separately develop per-layer matrix checks with numerical tolerances for fp16 services, and define the scope of each path.
- Develop collateral, slashing and repeated-audit mechanisms. Expand tests for model substitution, output tampering, replay and beacon manipulation.
- Publish protocol specification v1, a model-registry prototype, a Verifier CLI and SDK, and test vectors.
Development Targets: For a 1.1B model with a context length of up to 512 tokens, generate a proof within 60 seconds and verify it within 2 seconds per request. Correctly reject at least 25 adversarial negative test cases. Reports will identify hardware, output length, sampling scope and preprocessing costs. These are targets, not measured results.
SLP Stage 2 · Planned
Scale and Performance
- Optimize weight-storage and accumulation precision, develop an int8 Tensor Core path and move integer execution and quantized lookups to GPUs.
- Accelerate sumcheck, multiscalar multiplication and commitment generation, measuring proof-generation time and GPU memory usage separately.
- Optimize attention proofs and segmented proofs at context lengths of 512, 1k, 4k and 8k tokens, publishing cost curves across models and context lengths.
- Integrate multi-request proof packing into services, balancing batch size, waiting time and per-request cost.
- Develop deterministic inference and reproducible outputs under fixed models, inputs, random seeds and runtime configurations.
- Retain computation records for disputes and support full-proof generation in chunks. Measure the time and storage required to escalate from sampled to full proofs.
- Obtain an independent cryptographic audit and address findings in the protocol, implementation and numerical constraints.
Development Targets: Run inference, commitment generation and sampled proving for a 7B model on one 24 GB GPU at a context length of 2k tokens, targeting under 5 minutes for a proof covering five layer groups. Run the equivalent workflow for a 70B model on one or two 80 GB GPUs at a context length of 2k tokens, targeting under 5 minutes for a proof covering five layer groups. Achieve 100% output-token reproducibility within a test set with fixed models, inputs, random seeds and runtime configurations. These timing targets apply to proof generation, not the entire workflow, and are not measured results.
SLP Stage 3 · Planned
Production Integration and Ecosystem
- Integrate verification with mainnet settlement and support dispute escalation from sampled to full proofs for models that follow defined integer fixed-point rules.
- Research recursive proof wrapping to reduce on-chain verification time, proof size and processing costs.
- Expand support for dense models and reusable verification operators, with model integration configurations and testing tools.
- Verify expert selection, token dispatch and the combination of expert outputs for MoE models such as Mixtral and DeepSeek.
- Refine routine tolerance checks and numerical audits for disputes involving floating-point services, and publish their scope and security parameters.
- Complete key management, retention of proofs and computation records, monitoring, alerts, service-level agreements (SLAs) and cost reporting.
- Publish protocol specification v2, reference implementations and test vectors. Run bug bounty programs and ongoing adversarial testing.
Launch Targets: Stable mainnet operation, support for at least three model families and full-proof dispute handling for models that follow the defined integer fixed-point specification.

