trueopen
An Open GPU Network for Verifiable AI Inference
Cost-Efficient Verification Trustless Coordination High Concurrency Privacy Protection
Why TrueOpen
Model maintainers publish their service terms. Independent GPU providers run the models and accept inference tasks. The network verifies the computation, preserves the evidence, and settles payments based on the verification results.
We also need an open GPU network to run them. A model can be freely available while access to its inference service still depends on the platforms willing to host it. An open GPU network lets independent providers deploy models and serve users directly.
An inference result alone does not tell you whether the provider used the agreed model and settings. TrueOpen uses the computational properties of large language models and cryptographic verification techniques to check whether providers performed the computation as agreed.
Users place their budget in escrow before a task begins. Nodes stake funds to back their commitments. The protocol uses verification results to settle payments, issue refunds, and penalize misconduct. Users authorize tasks with an address and a digital signature. They can also encrypt inputs and outputs with AES-256-GCM authenticated encryption. Data keys are wrapped using ECIES and delivered to authorized recipients.
Network Overview
Model maintainers publish their model configurations, verification rules, and rates. They can also choose to charge a model maintenance fee.
GPU providers stake funds, choose which models to support, and decide which tasks to accept. They can pause their service at any time, but must fulfill commitments they have already made.
The network checks whether nodes performed inference as agreed, using either Logprob majority-consensus verification or sampled layerwise cryptographic verification.
Logprob verification uses prefill to recompute an existing token sequence in parallel. In sampled layerwise cryptographic verification, proofs are generated for mandatory checks and randomly selected intermediate layers of fixed-point quantized models. Floating-point models use randomized matrix product checks to assess deviations against numerical tolerances, reducing the need to recompute full matrix products.
Users receive inference results first. The network then completes verification and settlement. If a node is confirmed to have cheated, the funds held in escrow for the task are returned to the user.
GPU nodes process tasks in parallel. The data availability layer stores the full task materials, while Builders submit task-stage records in batches. This reduces the need to put large amounts of data and repeated transactions on-chain.
Users do not need to disclose their names or banking details in task orders. They can choose to encrypt inputs and inference results. Decryption keys are shared with authorized participants according to their roles in the task.
Participants follow public rules that cannot be tampered with. The blockchain records their commitments and holds task funds in escrow. The protocol distributes payments and holds participants accountable based on verification and dispute outcomes.
How It Works
Model maintainers register models, and GPU providers register nodes. Once a user submits a task, the protocol selects a node to run inference. The result is returned to the user, followed by verification and settlement.
Model maintainers register the model, its runtime configuration, and its verification rules, and publish the applicable fees.
Register model → Define rules and feesGPU providers register their nodes, stake funds, and declare which models they support and what computing resources are available.
Register node → Stake funds → Declare supported modelsUsers choose a model and runtime settings, optionally enable encryption for their inputs and outputs, and sign a task order. The protocol holds the task budget in escrow.
Choose model → Sign task order → Fund escrowThe protocol uses a verifiable random function (VRF) to preselect candidates. After nodes submit their participation requests, the candidate list and selection weights are frozen. Randomness from a specified future block then selects the Worker.
Submit participation requests → Freeze candidates and weights → Select WorkerThe selected Worker runs the specified model, generates the output, and records evidence of the computation.
Run model → Generate output → Record evidenceThe Worker delivers the inference result to the user without waiting for verification or settlement.
Deliver result → User receives outputVerifiers independently check the computation under the model’s verification rules, using either Logprob recomputation or sampled layerwise cryptographic verification. In the latter approach, Verifiers check proofs for fixed-point quantized models or perform numerical audits for floating-point models.
Check computation → Submit verification recordsBased on verification and dispute outcomes, the protocol distributes fees, processes refunds, and holds responsible nodes accountable. Earnings are released once the protocol’s release conditions are met.
Confirm outcome → Settle fees → Release earningsFunds & Coordination
Users fund escrow before a task begins, and nodes reserve collateral from their stakes. After service is delivered, the protocol distributes fees according to verification results. Confirmed cheating triggers refunds and penalties for responsible nodes. Until verification and disputes are resolved, the associated earnings and collateral cannot be withdrawn in full.
Inference Verification
Verification must detect computation that violates the agreed rules while keeping costs under control. TrueOpen uses two verification approaches based on how large language models perform inference and on cryptographic proof techniques, reducing the cost of recomputation and proof generation.
Verifiers feed the original input and the generated token sequence into the agreed model for a single parallel prefill pass. Following the model’s rules, they compare the output tokens’ log probabilities (Logprobs), rankings, and required Top-K candidate distributions, and check whether each output token falls within the allowed candidate set. These checks help detect model substitution or generation that violates the agreed rules. For MoE models, Verifiers also compare the expert IDs selected at specified layers and positions. They do not need to regenerate the answer token by token.
Three Verifiers compute independently and commit their values before revealing them for comparison, preventing them from copying one another’s results. Numerical tolerances and batch statistics reduce false judgments. Majority consensus requires valid, consistent results from at least two Verifiers.
Cryptographic commitments bind the model and computation materials before random sampling, preventing later substitution. For fixed-point quantized models, proofs cover mandatory checks and sampled layers. For floating-point models, randomized matrix product checks determine whether numerical deviations fall within the agreed tolerances.
Sampling reduces verification costs, and its coverage determines the chance of detecting cheating. Stakes and penalties increase the losses that cheating nodes face when caught.
Data Availability
Verification must continue even after the Worker leaves. Multiple Builders store task materials in the data availability (DA) layer. On-chain commitments allow participants to check that retrieved materials have not been altered.
Data & Access
Privacy protection covers both user identity and inference content. Users authorize tasks with a public-key address and a digital signature, without disclosing their names or banking details.
They can optionally encrypt inputs and inference results using AES-256-GCM authenticated encryption. Data keys are wrapped using ECIES public-key encryption and delivered to authorized recipients according to their task roles.
The project team, storage nodes, and other organizations cannot decrypt user content solely by virtue of their identity or administrative privileges.
The user’s client encrypts the input. The Worker encrypts and returns the result in chunks, which the client decrypts for display.
The protocol selects Workers and Verifiers using future randomness. The required keys are then delivered to the selected nodes. Workers and Verifiers need access to the plaintext relevant to their assigned computations.
Builders store ciphertext and wrapped keys without holding the unencrypted data keys. Materials are retained for the period required by the task and any review, then deleted according to the retention rules.
Performance & Scaling
Each task order generates records for node participation, selection, verification, and settlement. The network performs computation off-chain, stores complete task materials in the DA layer, and submits eligible records in batches.
GPU nodes accept tasks concurrently. Verifiers group tasks by Worker, model, and verification rules for batch recomputation. Users receive their results first, followed by verification and settlement.
The DA layer stores inputs, outputs, and computation evidence. The blockchain records signatures, data commitments, task states, and participant obligations. When a review is needed, authorized participants retrieve the materials and check them against on-chain commitments, without repeatedly uploading the full materials to the blockchain.
Builders collect task-stage records that the protocol allows to be submitted together. The blockchain still checks each record’s signature, associated task, and prerequisites before updating the task. Batching reduces transaction overhead while preserving every individual check.
Batching does not eliminate the blockchain’s state updates or consensus work. Further optimization and load testing are planned. Task completion rates, latency, and backlog must be measured under the same workload to make meaningful comparisons.
Developers & Applications
Developers use the API to request inference and smart contracts to coordinate application workflows. Contracts define when calls can be made, their budgets and permissions, and what happens after a result is returned or verification is complete.
Research
Roadmap
See what is complete and what we are developing next, including inference services, privacy protection, and the testing and launch of cryptographic verification.
View the Development Roadmap →Join Us
TrueOpen is a straightforward, practical, and sincere team. If you are interested in TrueOpen and have deep expertise in cryptography, blockchain, or AI, we welcome your involvement. There are many ways to contribute.