Live now · Get your API key

Testnet

The live Ambient testnet (external services, the on-chain Ambient Main Program, and the off-chain miner/validator components) plus how developers, miners, and validators take part.

The testnet is live. Developers send queries through the API service or a chat demo, miners bid on and serve them, and validators audit the results.

High-level testnet architecture#

The testnet architecture includes an on-chain program, off-chain miners/validators and external services.

EXTERNAL SERVICESWebAPI Service FEChat DemoAPI ServiceWeb2 APIsauction appRPC NodeON CHAINAmbient Main ProgramBucket & bundle requestsCreate auction for bundleSelect auction winnerSelect validators & validation rangesCollect validation resultsTrack success/failure on chainRequest dataOFF-CHAIN MINERSGPU Miner/ValidatorRPC/ValidatorListen for auctionsPlace bidsClose auctions / listen for winning bidsManage query data transferListen for validation selectionWrite result on chainManage validation data transferManage vLLM clustervLLMOther minersResponse data

High-level Ambient testnet architecture. External services: the Web reaches an API Service FE, which calls the API Service, and a Chat Demo; all of them feed the Web2 APIs layer, which forwards requests to the auction app, which submits them to an RPC Node. On chain: the RPC Node drives the Ambient Main Program, which buckets and bundles requests, creates an auction for each bundle, selects the auction winner, selects validators and their validation ranges, collects validation results, and tracks success or failure on chain. Off-chain miners: each GPU Miner/Validator runs an RPC/Validator service that listens for auctions, places bids, closes auctions and listens for winning bids, manages query data transfer, listens for validation selection, writes results on chain, manages validation data transfer, and manages the vLLM cluster; that service drives a vLLM instance which returns generated tokens. Request data flows from the chain to the miners and response data flows back. Other miners participate in the same auctions and validation.

High-level testnet architecture: external services hand requests to the auction app and RPC node, the on-chain Ambient Main Program bundles and auctions them, and GPU miner/validator nodes serve the inference on vLLM.

External services#

  • Web/API layer: Public users interact through an API service front-end or a chat demo. The API service proxies requests to Web2 APIs (such as HTTP or existing AI services) and forwards valid requests to the Ambient network.
  • Auction app: The auction app submits requests to an RPC node, which interacts with the on-chain program.

On-chain program (Ambient Main Program)#

The Ambient Main Program runs on the Solana-compatible chain and manages core logic:

  • Bucket & bundle requests: it groups individual queries into bundles to improve throughput.
  • Auction creation and winner selection: the program creates auctions for each bundle, receives bids from miners and selects winners. The litepaper explains that queries enter the system via an auction contract where users specify a maximum time and payment; miners bid, and refunds are issued if miners complete the query within the time limit. Validators are chosen randomly based on Logit Stake (LStake).
  • Validator selection and validation ranges: for each bundle, the program assigns validators and defines the token ranges they must validate.
  • Result collection and tracking: the program collects validation results and records success or failure on-chain, ensuring that miners are compensated only when results are correct and timely.

Off-chain components#

  • RPC node: Bridges the on-chain program with miners. It sends auction events to miners, receives bids, and forwards results back to the chain.
  • GPU miner/validator: Each miner runs an RPC/validator service and a vLLM instance (a high-performance LLM runtime). The miner:
    • Listens for auctions and places bids.
    • Retrieves bundled queries and performs inference using the network's LLM.
    • Produces hashed logits and submits partial results to the chain for PoL verification.
    • Listens for validation assignments and recomputes selected tokens to verify other miners' results, writing validation data on-chain.
    • Manages the vLLM cluster (loading the foundation model and scaling inference across GPUs).
  • Other miners: Compete in auctions and perform inference/validation just like the primary miner. Competition for auctions incentivizes low latency and efficient computation.

Workflow example#

  1. User query submission#

    A developer or agent sends a request via the API service, specifying constraints such as maximum response time and the amount they are willing to pay. Queries are grouped into bundles by the auction app.

  2. Auction and bidding#

    The on-chain program announces an auction for a bundle. Miners listen for auctions and place bids. Miners whose bids win commit to delivering the results within the agreed time. According to the litepaper, miners' bids are refunded if they complete the query within the specified period.

  3. Inference and result submission#

    The winning miner runs the query on its vLLM instance, generates hashed logits for each token and submits the output and PoL hashes to the chain. Validators are randomly selected based on their logit stake to audit the result.

  4. Validation#

    Validators recompute a small portion of the query (a randomly selected token) using the same context and model. If the hashed logits match, the result is accepted. This process ensures that validation is inexpensive (only one token of inference) compared with the original computation.

  5. Settlement and reward#

    When results are accepted, the miner receives compensation (transaction + inflation-based) and the user's payment is released. If the miner fails to deliver on time or produces incorrect results, they forfeit their bond and the query is re-auctioned.

Participating in the testnet#

  • Developers/users: To try the testnet, developers call the API service or chat demo with their queries. They can specify maximum response times and payment amounts. The network accepts HTTP and BitTorrent data sources via integrated oracles.
  • Miners: Potential miners should provision GPUs and run the Ambient miner software, which includes an RPC/validator component and a vLLM runtime. Miners need to listen for auctions, place competitive bids, execute inference tasks, and participate in validation. Because the network focuses on a single open-weights model, miners can optimize their hardware for predictable workloads. Onboarding today runs in curated waves on datacenter-class hardware. See Run a node for what a wave requires.
  • Validators: Validators typically run alongside miners. They should maintain synchronization with the blockchain, store the foundation model (or relevant shards) and be prepared to re-compute small portions of other miners' outputs. Validators are selected based on their logit stake and receive rewards for successful validations.

Keep reading#

  • Network architecture covers the four network roles and the life of a request from auction to settlement.
  • Run a node covers hardware requirements and miner onboarding.