Why Zycord Doesn't Need Its Most Ambitious Design (Yet)

Zycord was not born in the last few weeks. The design goes back years, to when I was testing and validating this model on my own, before any of it was public. From the start it was built toward one specific point: a network that scales through sampled verification and solves, in one move, the three limits of every blockchain, storage, bandwidth and contract execution, without giving up security.

What I did in the last few weeks was organize that design so other people can understand it. The result is section 12 of whitepaper v2.0, and it came with a decision: the path exists, it works, and today it is not needed. This article explains why.

Starting small on purpose

A design this size cannot launch all at once. So I started at the beginning: the paper, and a launch focused on eras 0 and 1, the virtual machine and tip tokens. That was the minimum to take the project off paper and put a network live.

Whitepaper v1.0 described that project. v2.0 describes the network that is running. Along the way, implementation showed what was essential and what was dead weight: certificate insurance, forced-path queues and fraud proofs are gone. What remained is the core, simpler than planned, and working.

The thesis never changed. On Zycord, a transaction is not a request for the network to execute something. It is a certificate: the program, what it read and what it wrote, together. Any computer checks that certificate from its bytes alone, without consulting the network’s state, in parallel, thousands at a time. The chain never executes. It orders certificates and applies the ones that still hold.

What other networks carry

Solana bets on fast machines. Every validator executes every transaction against the global state, and keeping up requires an expensive server. The result is a fast network with few validators, and a history of outages when volume spikes.

Cardano came closer: validating a transaction there is deterministic and local. But scripts still run on every node, and when many users contend for one contract, ordering is decided off chain, by “batchers” the chain neither recognizes nor protects.

Polygon, Arbitrum, Optimism and rollups in general took execution off the main chain and left it only verifying. That is the right division. But each rollup is a second chain, with a bridge, a single sequencer and, depending on the kind, a week of fraud disputes or an expensive prover. Two rollups cannot talk without another bridge.

Gnosis and the other Ethereum-compatible networks inherit the original limit: every node executes everything, in order, and capacity is that of one node.

None of them is wrong. Each hit a limit and built on top to work around it. Zycord is born without the limit.

What the certificate does away with

A Zycord certificate is, in practice, a rollup batch, with one difference: the main chain never executes it, it only checks it. So:

• No bridge, because there is one state.
• No fraud dispute: an invalid certificate is its own proof, in one message.
• No prover, because there is no circuit to build.
• The sequencer is per contract. If it disappears or censors, any user can still transact through the forced path.
• Two contracts with different sequencers compose into one atomic certificate. Where two rollups need a bridge, Zycord needs one more signature.
• Payments never contend. Transfers and tips are sums, and sums commute. Ten thousand tips in one block are ten thousand additions, zero conflicts.

All of it in a protocol that fits in fifteen sections, with a node that runs on an ordinary computer.

On ZK

Validity rollups use zero-knowledge proofs. It is a beautiful technology, and it works: a prover executes the transactions and produces a mathematical proof that it executed correctly; the chain checks the proof instead of redoing the work.

The price comes in layers. Generating the proof costs hundreds of times more than executing, which concentrates the prover in few hands and adds latency. Programs have to become circuits, with tooling that changes every year. Many systems depend on an initial trust ceremony. And the code is among the most complex in blockchain, with an attack surface to match; there have already been provers that accepted invalid proofs, caught by audit. Only time validates this kind of technology for good.

Zycord avoided that on purpose. Instead of a mathematical function proving that an execution happened, the virtual machine’s execution, which is deterministic, becomes something proven by its own bytes. To check it, re-execute it. Nothing outside the certificate is needed. That is the property of a proof that matters, being verifiable on its own by anyone, with no circuit, no prover, no ceremony, and the complexity of a virtual machine the industry has audited for ten years.

The path kept in reserve

Sampled verification is the step all of this was designed for. Instead of every node checking every certificate, each certificate is drawn to a group of verifiers. The curve inverts: today, each node that joins adds security but not capacity; with sampling, it adds both, because each one checks a smaller share. Bandwidth falls in the same proportion, and storage follows, with the pruning the network already does.

It is the goal the blockchain community has chased for years by different roads: sharding, rollups, parachains. All of them partition state, and lose atomicity across partitions. Zycord partitions verification without partitioning state, because who checks a certificate is a free choice when validity is a function of the bytes. The state stays one. Every transaction stays atomic.

I designed and validated this years ago. It works. And I put it in the drawer for the simplest reason: today’s network already verifies far more than any demand it will meet in the coming years. Investing now in an era nobody will use any time soon is trading security for ambition. Section 12 holds the map, with direction and trade-offs, for when demand arrives.

What comes next

Era 2 is the switch from proof of work to proof of stake. Simple, with the fewest new rules possible, without touching verification. The computation that hashes today will verify certificates instead. The rest stays as it is.

Zycord is ahead of its time not for having more mechanisms, but for having fewer. A design that solves at the root what other networks solve in layers. The path to scale beyond that is written, and waiting.

— Simstoshi