Introducing Voyager: Hyperscale Payments for Agentic Commerce

Benchmarked at 21 million transactions per second, Voyager is a new blockchain architecture for an internet where millions of agents pay for content, data, and services on demand.

Today we’re introducing Voyager, a blockchain architecture for hyperscale payments. As the agentic internet grows, it will need payment rails built for machines: open, instant and able to scale to millions, and eventually billions, of transactions per second. In our first full benchmark, Voyager processed a sustained 21 million transactions per second across 100 million accounts over 5 hours.

Last week Celestia Fibre went live on mainnet, giving blockchain applications onchain bandwidth at unprecedented scale. Voyager is the first execution layer designed to harness the power of Fibre’s throughput. We’ve been building toward this scale since 2019, when millions of transactions per second and gigabyte blocks seemed far beyond what blockchains would ever need. Now, the agentic internet is making that ambition an urgent necessity.

An Internet of Agents

Today’s internet was built for humans. Humans making search requests. Humans visiting webpages and clicking ads. Humans purchasing subscriptions for APIs and data feeds. But with the rise of AI agents, internet usage patterns are changing dramatically. Increasingly it is agents – not humans – who are searching, scraping webpages and calling APIs.

In order to achieve an outcome, build a product, or find an answer for a human, agents are likely to visit many websites, and use several software tools and data feeds in rapid succession. This not only increases the volume of traffic, but also fundamentally challenges two of the core business models of the internet: advertisements and subscriptions.

Unlike humans, agents don’t click ads. Webpages that previously shared their content freely in exchange for monetising their traffic via advertising are seeing their revenue plummet. 

And subscriptions don’t work for agents that need to consume data and software on-demand. Setting up a subscription is too much of an up-front investment for an agent that may only need the service or data once, and is too slow for an agent that needs an answer immediately.

To support the growth of the agentic internet, a new usage-based business model is needed. One in which content hosts and service providers can charge agents per webcrawl, per request, and per unit of data.

New Payment Rails for a New Internet

Transitioning to a usage-based business model sounds simple, but today’s payment systems can’t handle per-use charges. Businesses need payments that settle at the speed of a web request, cost a fraction of a cent, support flow between counterparties that have never transacted before, and scale to match the vertical growth of agentic traffic.

Even the most appropriate existing payment system, credit cards, fail on almost every count. Card networks charge about 30 cents per transaction, making micropayments impractical. A card payment takes 1-3 seconds to confirm, too slow for agents that require responses at the speed of a web request. And card networks like Visa can only handle around 65,000 transactions per second, enough for people but nowhere near enough for even a modest agentic economy. 

Where card networks and traditional payment rails fall short, blockchain-based payments have the edge. Modern blockchains can settle payments for hundredths of a cent or less, confirm payments in under a second, and enable payments between previously unknown counterparties.

But there’s just one problem. Even the fastest blockchains of today can only process hundreds of thousands of transactions per second. More than Visa, but still far short of the capacity needed to support the predicted volume of agentic payments. Cloudflare’s CEO Matthew Prince has said a micropayment system for agents would “need 10 million TPS from day one, [and] eventually 100 million.”

That’s why we built Voyager. Benchmarked at 21M TPS, Voyager provides the first fully onchain payment rails scalable enough for agentic commerce.

How Voyager Works

Voyager is an application-specific blockchain architecture, designed from the ground up for one thing: scalable payments. The core principle is to split payment processing into separate threads that run independently of each other, so nothing ever blocks the executor, the thread that updates balances.

Transactions first pass through an ingress layer, which checks signatures and batches payments before they reach the core Voyager node. Adding ingress machines increases verification capacity.

Batches then go into a ring buffer, borrowing from the “Disruptor” design LMAX built for stock exchanges. Each batch gets processed in order, but the different threads work on different batches in parallel: the journal records the newest, the executor processes the next, and the Fibre publisher and Stargaze, a storage service we built for Voyager, writes older ones across several databases on separate disks. If one thread falls behind, only the threads that need its output slow down. If the queue fills up, Voyager holds back new transactions rather than overloading.

The executor fetches the data each payment needs ahead of time, so it never waits on any other thread and memory latency is rarely a bottleneck. That is how one thread on one core can handle 21 million payments a second.

Payment logic is built-in rather than run on a general-purpose virtual machine, and state lives in a flat table instead of a Merkle tree, so there’s no state root to recompute every block. Every transaction is published to Celestia Fibre, so that anyone can replay it and check that each payment was applied correctly.

Benchmarking

We benchmarked Voyager on random transfers between 100 million accounts. Throughput averaged 21.2 million transactions per second across a five-hour run, peaking at 21.6 million.

The run shown above includes about 400 billion transfers. The node’s memory usage stayed flat at about 48 GB throughout the benchmark, because the ring buffer design caps how much work can be in flight. Execution ran on a single CPU core at 96–100% utilisation. The journal and the Fibre publisher each moved about 4.8 GB/s, carrying full transactions including signatures.

The benchmark measures a single Voyager node. It doesn’t yet compute state roots, replicate data to other machines, or serve real-time transaction status queries at this volume, though it does produce receipts for every payment. Voyager already saves everything it needs to recover from a process crash, and replication, state roots and queries are next.

21 million TPS is just the starting point. Sharding the journal and Stargazer across more disks lifts the storage limit, and the design extends to multiple cores and Voyager instances, all without moving payments offchain. If the agentic economy grows as much as some predict, Voyager has the capability to scale to match it.

We will share more details about Voyager’s design and our benchmarking setup in a forthcoming technical deep dive.

Every Market and Every Agent Onchain

In January we set out Celestia’s Vision 2.0: to bring every market onchain. Fibre, which went live on mainnet on October 19, provides the raw onchain capacity to make this vision possible. In July, we acquired Sovereign Labs to build execution layers fast enough to take advantage of Fibre, and Voyager is the first product.

Voyager also marks a step-change in how we work at Celestia Labs. For years, the default in crypto was to build a platform and wait for an ecosystem to show up. We’re starting from the other end: finding a real and urgent problem, working with the people who have it, and building a full stack solution for it.

Beyond markets, we want to bring every agent onchain. With increasingly long task horizons and sprawling subagent networks, agents will make far more payments than any person could. Soon they’ll rent compute by the second, hire each other for tasks and pay publishers for every paragraph they read. They will also trade and hedge with each other, and eventually some might run businesses with their own treasuries. That could mean billions of payments a second, and require a whole stack of products built for agents rather than people.

And as agents act with more autonomy, humans will need to find new ways to stay in control. On fast, open rails, safeguards can be enforced in code. Agents will also need to coordinate without trusting each other, and a shared public ledger allows them to do so whilst providing a record of what every agent agreed to and did, verifiable by anyone. If something goes badly wrong, the final backstop is social consensus rather than token-holder governance.

This is the future we’re building for; economic rails fast enough for machines, but governable by humans.

What's Next

We’re taking Voyager towards production, and over the coming weeks we’ll publish deeper technical posts to explain its architecture. In the meantime, if you need payments at a volume no existing chain can handle, please get in touch.