/en/articles/cloudflare-bets-on-quepaxa-a-consensus-algorithm-with-no-mandatory-leader-for-its-global-control
Cloudflare bets on QuePaxa, a consensus algorithm with no mandatory leader, for its global control plane

Cloudflare published on November 11, 2026 why it chose QuePaxa, a consensus algorithm that, according to the company itself, had never been deployed in industry, for Meerkat, the experimental service it wants to use to manage the state of its global control plane. The bet is an odd one: almost everything that stores critical configuration today (etcd, Consul, ZooKeeper) uses Raft, Paxos, or similar variants, which depend on a leader. Cloudflare says that leader is precisely the weak point when your replicas are spread across the entire planet and the network between them does whatever it feels like. If you've ever watched an etcd cluster lose writes because of an election that never ends, this story is going to sound familiar.
What Meerkat is and why it exists
In the Meerkat introduction post, Cloudflare explains that many internal services need to read and modify the same state from its more than 330 data centers, with two guarantees: that nobody reads inconsistent data and that writes can keep going even if some data centers or links fail. Meerkat is an ordered log on top of which applications run, such as a transactional key-value store and a lease system. All replicas agree on the same order of events and, therefore, build the same state.
The hard facts about its current status:
- It has been built by the Cloudflare Research team for a year, according to the announcement.
- It is not in production. They ran proofs of concept with up to 50 replicas spread around the world.
- For now it is internal only and meant for small pieces of control plane state, such as knowing which machine is the leader of a replicated database.
- Cloudflare says that, as far as it knows, this will be the first industrial deployment of QuePaxa at global scale.
- It tolerates
ffailures in a system of2f + 1machines, like any majority consensus, and it does not tolerate Byzantine faults (malicious replicas).
The motivation has a history. In the QuePaxa post, Cloudflare recalls that in 2020 a partial switch failure degraded a consensus-based system and left the dashboard 80 times slower for six hours. No data was lost, but writes were impossible. The company says it has had several incidents caused by unavailable leaders in consensus systems.
The problem with the leader
Cloudflare describes two ills of leader-based algorithms when they run over the internet:
Destructive interference. In Paxos, two proposers can block each other indefinitely by each raising their ballot number. Raft and Multi-Paxos avoid this by using a single leader, which also decides in a single round trip. But when that leader goes down, electing the next one becomes a competition again: several candidates ask for votes at the same time, none gathers a majority, and another election is called. Cloudflare calls this a metastable failure: a two-second network outage can trigger elections that last far longer than the outage.
Failure detection. To know that the leader died, replicas wait for a message that never arrives. On a wide area network you can't tell a dead server from a slow network, so the detector guesses. If it guesses wrong, the system halts for an unnecessary election. If it guesses right, it still takes a while: the etcd tuning guide recommends an election timeout of at least 10 times the round-trip time, and with trips of hundreds of milliseconds between continents, Cloudflare estimates around one second just to notice the failure. HashiCorp, for its part, has strict latency requirements for deploying Consul.
How QuePaxa works
QuePaxa came out of a paper presented at SOSP 2023 by Pasindu Tennage, Cristina Băsescu and colleagues, most of them from the DEDIS lab at EPFL. Its title says it all: Escaping the tyranny of timeouts in consensus. Cloudflare sums up its three key decisions:
- The leader is optional. Any replica can propose. The leader only has one advantage: it is the only one that can decide in a single round trip.
- There is no failure detection. Nobody waits around to declare anyone dead.
- Constructive interference. Each proposal carries a random priority (the leader's is the maximum). When a proposer sees a proposal with a higher priority than its own, it adopts it and starts spreading it. Instead of fighting, proposers converge.
Each round has four phases. In phase 0, proposals are made and the highest-priority one is adopted; if the leader reached a majority first, it decides right there (the fast path). In phase 1, what was adopted is broadcast. In phase 2, a majority is asked what the highest proposal they saw was; if it matches your own, you decide. In phase 3, anyone who didn't decide adopts the best thing they find and moves on to the next round. Safety comes from a simple property: any two majorities always share at least one replica, so nobody can decide something different from what has already been decided.

The trick to not depending on the leader without wasting its speed is hedging: clients send their request to all replicas, and the ones that aren't leaders wait a short time to give the leader a chance. Cloudflare notes that in its implementation it deviates from the paper: it is the client, not the replica, that waits that time, in order to send fewer messages. That delay is not a failure detector, so it can be as short as you like; according to the post, a 5 ms hedge on a 100 ms network just means more active proposers, while a timeout like that would freeze Raft. The cost is more bandwidth and, sometimes, more rounds.
The paper predicts a 50% chance of deciding in each round; Cloudflare says that in practice it is quite a bit higher thanks to convergence. According to the paper's abstract, the authors' prototype reached 584,000 commands per second on a LAN and 250,000 on a WAN, comparable to Multi-Paxos, and under denial-of-service attacks or slow leaders it kept a median latency under 380 ms on a WAN.
What Cloudflare saw in its tests
In evaluations with servers on almost every continent, Cloudflare reports:
- More than 95% of decisions are made by the leader in the first phase.
- In a test with a leader failure, the decision rate dropped to about 65% and went back to 100% when the leader was replaced a minute later. All decisions in that interval were made in phase 2.
- When something isn't decided in the first phase, throughput drops to one third at most, because three round trips are needed instead of one.
- They say they never saw it stop completely, and that they can change which replica is the leader while the cluster is running.
Heads up: these are Cloudflare's own results on a system that is not yet in production. There is no independent benchmark.
What is still unresolved
Cloudflare is frank about the risks. QuePaxa is not as battle-tested as Raft or Paxos, and they are also extending it: the original design is crash-stop (a replica that goes down never comes back) and they need crash-recovery (it comes back with its state). That is why they say they are formally verifying their Rust implementation, on top of simulation and fault-injection testing, and they promise more posts about that and about benchmarks.
There are also design limits that come from the Meerkat post: it isn't meant to be a general-purpose database, and the latency of each decision depends on the distance between a majority of replicas (one trip with the leader, three without it, more if there are simultaneous proposals), which is why they aim it at data that is written rarely but has to be consistent. They compensate with batched writes, reads that accept stale data but never inconsistent data, and compare-and-swap-style operations.
My take
For anyone running small or mid-sized infrastructure, this is not something to install tomorrow: Meerkat is internal, no code has been published, and QuePaxa has no mature implementation you can drop in place of etcd. What's valuable is the diagnosis. If you have a Raft cluster (etcd, Consul, the one in your Kubernetes) stretched across distant regions, the pains Cloudflare describes are yours: timeouts impossible to tune, elections that chain together, and writes blocked by a slow link, not by a dead server. The practical lesson today is still the boring one: keep your Raft replicas close to each other and respect the vendor's latency requirements.
The part that does strike me as a change in mindset is hedging: stop guessing whether something died and just send the request in several directions, accepting to pay a bit more network. If the formal verification goes well and Cloudflare publishes more than posts, QuePaxa could be the first serious alternative to Raft's monopoly in years. For now, it's a very well-documented experiment.
Sources
- Choosing QuePaxa, an unusual consensus algorithm (Cloudflare, Nov 11, 2026)
- Introducing Meerkat: an experiment in global consensus (Cloudflare)
- QuePaxa: Escaping the tyranny of timeouts in consensus (SOSP 2023, ACM)
- A Byzantine failure in the real world (Cloudflare, 2020 incident)
- etcd v3.4 tuning guide
- Consul reference architecture: network latency (HashiCorp)