Q token mark QUADPublic Accountability

How it's built

Why QUAD runs two nodes

Most of QUAD's chains aren't one program — they're two working together. Here's why, in plain terms.

Two jobs that pull apart

A blockchain has to do two very different things at once. It has to agree on what happened and in what order — slowly and carefully, with everyone checking everyone. And it has to do the actual work — move money, store files, repair data, match trades — quickly.

Careful and quick pull in opposite directions. A program built to be careful is a poor place to do fast work, and a program built for speed is a dangerous place to keep the final record. Most chains pick one and live with the trade-off. QUAD splits the two.

So each chain has a second worker

Every QUAD chain except Core runs a steady "decides what's true" node next to a faster "does the work" node. The worker is different on each chain, because each one does different work.

Liquid

A custom high-speed engine that takes in fast trades, built for speed so the careful part doesn't have to be.

Infra

A small, sturdy tool that repairs stored files byte by byte and proves it did the job.

Bridge

A full node of the outside chain it connects to, so it can check events on that chain directly instead of trusting someone else's word.

Core

The exception. Core is the value layer, kept deliberately simple and single — no second worker.

The worker never gets the final say

This is the rule that makes the split safe: the fast worker can only ever make a suggestion. A trade proposal, a repair receipt, a "this happened on the other chain" report — each one comes with its evidence attached, and the chain re-checks it before anything counts.

The worker can't change a balance, settle a trade, or admit a value on its own. It hands its work over, and the careful side decides what that work means. Fast is allowed to be fast precisely because fast is never allowed to be final.

Why this is safer for you

The split isn't just tidy engineering — it changes what can go wrong.

Speed can't cost you money

The fast part has no power to move your balance, so a bug or a rush there can't quietly change what you own.

Each part is simple to check

A small worker that does one job is far easier to audit than one giant program trying to do everything.

A problem stays in its lane

If the fast worker fails, the chain just stops accepting its suggestions. The final record is untouched.

Nothing's final until it's proven

The same idea runs through the whole stack: a receipt isn't truth, a fast fill isn't a settled balance, a delivery isn't an admission. It gets checked first.

Liquid Infra Bridge Core Full architecture The limits