Celestia Voyager Sustains 21M TPS in Single-Node Benchmark

Celestia Labs has published a technical breakdown of Voyager after its specialized payment architecture sustained more than 21 million account-to-account transfers per second in testing. According to the official Celestia engineering report, the system was benchmarked against a state containing roughly 100 million accounts and processed about 400 billion random transfers across several runs. One five-hour benchmark averaged approximately 21.2 million TPS and reached a peak near 21.6 million, but the result measures a specialized Voyager node rather than live Celestia mainnet throughput.

Voyager is designed primarily for high-frequency payment workloads, including machine-to-machine transactions generated by AI agents. Instead of executing payments through a general-purpose virtual machine, it incorporates payment logic directly into a dedicated state transition function. The architecture sacrifices general-purpose execution in its current form to optimize a narrower transaction type at unusually high throughput. Celestia says it intends to make execution pluggable later so similar infrastructure could support exchanges and other market applications.

Single-Core Execution Reaches 21 Million TPS

One of Voyager’s more unusual design choices is that its state transition function remains single-threaded. Rather than distributing balance updates across multiple CPU cores, one thread owns the state, eliminating locking and cache-coherency overhead between concurrent executors. Celestia identified memory access rather than raw computation as the primary execution bottleneck and designed Voyager around keeping required account data close to the CPU.

The executor can prefetch state as far as 32 transactions ahead, allowing memory requests to begin before those balances are needed. Celestia reported 96%-100% utilization of a single CPU core during sustained testing. State is also organized around compact data structures rather than passing each payment through a conventional smart-contract VM. The resulting 21 million TPS figure therefore reflects a highly optimized payment state transition rather than equivalent execution of 21 million arbitrary smart contracts per second.

That distinction is important when comparing Voyager with other headline blockchain benchmarks. Sui previously recorded more than 6 million operations per second during an AI-agent experiment, but those operations occurred through programmable tunnels that function as offchain state channels before settlement to Sui. Aptos has separately tested MonoMove with execution improvements of up to 55x for particular Move workloads. These systems measure different execution boundaries, making their headline TPS figures unsuitable for direct one-to-one comparison.

Pipelining Keeps Storage From Blocking Execution

Voyager separates execution, journaling, persistent storage and data publication into independent pipeline stages coordinated through a shared ring buffer. While the state transition function executes one batch, another stage can record newer transactions to disk and others can persist earlier state changes or publish transaction data. The components process different batches simultaneously, allowing slower I/O operations to occur without continuously blocking the execution thread.

A backpressure mechanism prevents that pipeline from consuming unlimited memory when one component falls behind. The ring contains 4,096 slots by default, and when downstream stages cannot process data quickly enough, upstream processing eventually pauses rather than allowing queues to grow indefinitely. During the benchmark, Celestia reported memory remaining near 48 GiB throughout the run. The design therefore targets sustained throughput rather than relying solely on a short burst that exhausts progressively more system resources.

Persistent balances are handled by Stargazer, Celestia Labs’ custom state-storage engine running on a separate machine. Stargazer can distribute state changes across multiple RocksDB databases and disks, while the Voyager node maintains a single executor. The benchmark’s journal and data-publication stages each processed about 4.8 GB per second of transaction data, including full-size signatures.

Every transaction input is also passed to a Fibre publisher so the underlying data can be made available for independent replay. Fibre itself became available on Celestia mainnet in October as a separate high-bandwidth data-availability system. Voyager’s execution benchmark should not be interpreted as 21 million TPS of current Celestia consensus throughput, because Fibre provides data availability while Voyager performs the payment execution.

Production Architecture Remains Incomplete

The benchmark also excluded several components required for a complete distributed production system. The load generator sent transactions directly to the Voyager node instead of through ingress, meaning signature verification was outside the measured throughput. Celestia argues that verification can scale horizontally by adding stateless ingress nodes, but that scaling model remains separate from the published 21 million TPS measurement. The test therefore demonstrated execution-pipeline capacity under sustained load, not end-to-end production capacity with every network service enabled.

Voyager also does not currently Merkleize its state during the benchmark. State-root computation is planned at lower frequency rather than after every block, which Celestia expects will avoid blocking transaction execution while introducing additional latency for light clients. Recovery after restart and replication to additional Voyager nodes are also still unfinished. A single executor processing transactions successfully is not yet equivalent to a replicated production blockchain capable of recovering and serving state under real network conditions.

The working state used in testing was also small enough to remain in RAM on one machine. Celestia has designed mechanisms to distribute storage across additional disks and eventually shard state across cores and Voyager instances, but those extensions have not yet produced the same benchmark under production conditions. The company itself has previously warned that blockchain benchmarks can overstate real-world performance, particularly when experimental configurations omit production constraints.

Voyager nevertheless demonstrates a different scaling approach for machine-generated payments, a market already attracting infrastructure such as programmable XRPL wallets for autonomous agent payments and blockchain-native payment systems elsewhere. The 21 million TPS result establishes the performance of Voyager’s specialized hot path; production relevance will depend on whether Celestia can preserve comparable throughput after adding replication, state commitments, signature verification, recovery and real-world query infrastructure.