The two generals put down their messengers.

An impossibility with its own name

Two generals camp on hills either side of a fortified city. If both attack at dawn, they win; if either attacks alone, that army is destroyed. Their only way to coordinate is messengers who must cross the valley — and any messenger might be captured.

General A sends: "Attack at dawn." But did it arrive? If it didn't, A attacks alone and dies. So B must send an acknowledgment — but did that arrive? If not, B can't know whether A will dare to go, so B needs an acknowledgment of the acknowledgment... In the 1970s computer scientists proved the regress never ends: over an unreliable channel, no number of messages can make both sides certain. It became the founding parable of distributed systems — and it is exactly the shape of the problem a sharded blockchain faces, where a transaction touching two shards must commit on both or on neither, over a network that loses messages and harbors liars.

Stop negotiating. Read the sky.

Here is the move the puzzle permits. The generals stop trying to agree during the campaign. Long before — in the capital, on solid ground — they agree on a rule: we attack at first light. Now nothing needs to cross the valley on the fateful morning. Each general looks at the same sunrise and derives the same moment. Their coordination is perfect, and it required no messenger — because the decision was moved out of the realm of messages and into a computation over facts both sides can see for themselves.

Four stages, zero decisions

A transaction declares up front which accounts it touches — that's its route. Every shard owning any of that state participates, and commitment runs through four stages. Watch for what's absent: at no stage does one side wait for the other's permission.

Order. Each shard commits the transaction into a block on its own chain, on its own schedule. No shard asks another for permission to proceed — ordering is the only thing a shard's consensus ever settles, and it settles it locally.

Provision. Each shard sends the others the state values the transaction needs. But a provision is not a message to be believed — it is a merkle proof against a quorum-signed committed block. Like the sunrise, it's a fact either visible or not; there is nothing to take on trust and therefore nothing to acknowledge. (Where the messenger's satchel does go missing, the fact is re-fetchable from anyone: a quorum having signed the block means a quorum provably holds its contents — the archive.)

Execute. Once a shard holds proven state from every counterparty, all participants possess byte-identical inputs. The engine is deterministic — same inputs, same outputs, always — so every shard computes the same receipts without exchanging another byte. This is the sunrise moment: the outcome now simply exists, everywhere, identically.

Certify. Each shard's validators sign a certificate over the result they computed — an attestation, not a vote; the certificate records an answer, it doesn't choose one. A transaction finalizes only with matching certificates from every participating shard; a single abort anywhere is terminal everywhere. Certificates over divergent results simply can never assemble into a valid commit — atomicity is enforced by the shape of the artifact.

Every way out is also a sunrise

A protocol is judged by its failure paths. If the happy path is deterministic but the abort paths depend on who heard what and when, the two generals are back. So every exit is likewise a pure function of committed facts:

One more piece of quiet machinery keeps the failure paths rare: deadlocks between transactions can't form in the first place. Before proposing, each shard's mempool enforces that no two in-flight transactions share any declared piece of state — a rule deliberately broader than the minimum, like a dinner host who never lets two guests be reaching for the same fork. And an abort, when it happens, is not a failure of the protocol but one of its answers: it's recorded inside the certificates with the same finality as a success, on every shard alike.

If you're thinking "two-phase commit"

Database people will recognize the silhouette — order under locks, then a commit step across participants. But the three features that define textbook two-phase commit are each specifically absent:

The honest footnote: the Two Generals impossibility is real and stands unbroken. You genuinely cannot make two parties certain of each other by messages. The design never needs that certainty — it needs both sides to hold the same frozen facts eventually, and quorum-signed chains are precisely a machine for making facts that cannot differ between honest observers, no matter when or how they arrive.