Liquid Democracy Tokenomics: Vote Delegation by Design

Liquid democracy tokenomics is the part of the delegation story that almost nobody designs. Every major DAO already runs delegation—Compound, ENS and Optimism all elect delegates—and the empirical result is well documented: in nearly all major DAOs the top 10 wallets can decide any contested vote, and where delegate markets exist, the top 3–5 delegates control more than half of the voting power. Delegation as practiced today does not fix plutocracy; it reorganizes it. Liquid democracy—delegation that is transitive, revocable at any moment, and split by policy domain—is the mechanism-design answer. But a naive implementation collapses into the same super-delegate oligarchy, only faster, because weight now flows through chains. This article builds the token model that keeps it from collapsing: four formulas, working numbers, and a calculator you can break.

What liquid democracy actually is

Governance sits on a spectrum. Direct democracy—everyone votes on everything—is precise and ruinously expensive in attention: DeFi protocols carry 200+ governable parameters, and 2% turnout on parameter votes is the norm, not the anomaly. Representative democracy—delegate wholesale, for a fixed term, under a free mandate—is cheap and slow to correct: a delegate who stops representing you keeps your vote until the next election.

Liquid democracy makes delegation fluid, in the sense that vote weight flows:

• Vote yourself whenever you care. A direct vote always overrides your delegate for that ballot.
• Delegate the rest. Your weight is exercised by a proxy you chose—and the proxy is transitive: your delegate may re-delegate onward, so weight flows down chains toward whoever actually does the work.
• Revoke at any moment. No terms, no election cycles. This is the digital form of the imperative mandate.
• Split trust by policy domain. Treasury to one delegate, protocol parameters to another, grants—vote personally.

Classical proxy law supplies the entire vocabulary: a delegation is a revocable power of attorney over voting weight; transitive delegation is sub-delegation; delegation can carry voting instructions, and voting against instructions is a slashable offence. None of this needs new jargon—it needs an economic layer that prices it correctly.

The core design decision: a vote is not property

The defining mistake of first-generation token voting was treating the vote as a transferable asset. A transferable vote creates a vote market, and a vote market clears at the price of the cheapest bribe: Vitalik Buterin’s critique of coin voting and Philip Daian’s “Dark DAO” work on hidden vote-buying cartels both reduce to this point. The Curve wars made it explicit—as soon as voting power became a liquid, wrappable position, whole businesses (Convex, Aura) were built on capitalizing it, a dynamic we dissect in the ve-tokenomics deep dive.

So the model separates two circuits:

1. Economic circuit—the GT token. An ordinary transferable token: supply, staking, treasury, rewards. Deliberately no “1 token = 1 vote” identity.
2. Voting circuit—weight W. A non-transferable quantity derived from staked GT through a square root. Delegation does not move tokens: the delegate receives a revocable proxy over weight, while the tokens stay with the principal and keep earning base staking yield.

The consequences do the work. A vote cannot be sold, because the proxy is non-tradable and revocable—any “sale” can be undone the moment the buyer stops paying. The only way to buy governance is to buy and stake GT yourself, which is expensive, visible on the market, and further blunted by the square root.

The math: four formulas

F1—Delegate weight with sub-delegation decay

Weight decays geometrically along the chain: a chain of depth k transmits λ^k of the original weight. At λ = 0.8 the second hop carries 64%—re-delegating pays only toward someone noticeably more competent than you. The delegation graph is kept acyclic by construction (an attempt to create a cycle is rejected at issuance), so W is computed in one pass in topological order.

Worked example: delegate Carol stakes 10,000 GT herself and holds proxies from 100 principals, each staking 2,500 GT. Each principal’s own vote is √2500 = 50, so the delegated pool is 100 × 50 = 5,000. At λ = 0.8:

F2—Own vote: square root of stake

The root is taken per principal, before aggregation—not over the delegate’s pooled total. A whale staking 1,000,000 GT gets v = 1,000: one hundred times the stake of a 10,000-GT holder, ten times the voice. Meanwhile a delegate representing a hundred small principals keeps the honest sum of their individual roots. Taking the root on the delegate’s pooled total instead would punish exactly the aggregation liquid democracy is supposed to encourage.

F3—Proxy half-life

An unconfirmed proxy melts; a one-click confirmation restores it to full strength. With T_half = 6 months:

This is the anti-ossification mechanism. In every long-running delegation system the ranking freezes: principals stop paying attention, and incumbent delegates coast on weight granted years ago. Half-life inverts the default—a delegate who has lost the audience loses the weight automatically, without requiring an active revocation from every sleeping principal.

F4—Delegate compensation: pay for work and skin in the game

Two properties matter. First, the budget is split over used weight only: a dormant super-delegate earns nothing, so hoarding proxies without voting is pure cost. Second, the min(1, v_i/(β·W_i)) factor demands the delegate’s own vote be at least a share β of the weight they represent—otherwise pay is cut proportionally. Proven abuse (voting against instructions, collusion) is punished by slashing the delegate’s own stake.

Worked example: quarterly budget B = 100,000 GT; Carol’s used weight is 5% of all used weight → base claim 5,000 GT. At β = 2% her required own vote is 0.02 × 4,100 = 82, i.e. own stake of 82² = 6,724 GT. She stakes 10,000 GT (v = 100 > 82), so the factor is 1 and she collects the full 5,000 GT.

Capping the super-delegate: saturation, not a cliff

Even with decay, popular delegates accumulate. A hard cap (“no delegate above 3%”) creates a cliff—and an incentive to split into shadow identities parked just under the threshold. A soft cap saturates instead:

The curve is smooth: marginal proxies are worth less and less, and no threshold exists to game. The haircut at W_cap = 3,000 (α = 3% of a 100,000 live-weight system):

Read the first row honestly: exponential saturation is not free—it shaves even small delegates (7.9% at one-sixth of the cap). That is the price of having no cliff anywhere. If your delegate set is small and trusted, a higher α or a piecewise curve may fit better; the table is exactly the trade-off you are choosing on.

import math

W_TOTAL = 100_000          # live weight in the system
ALPHA = 0.03               # soft-cap share
W_cap = ALPHA * W_TOTAL

for W in [500, 1500, 3000, 4100, 6000, 12000]:
    W_eff = W_cap * (1 - math.exp(-W / W_cap))
    print(f"W={W:>6}  eff={W_eff:7.0f}  haircut={100*(1-W_eff/W):5.1f}%")

Try it: delegate weight calculator

The calculator assembles F1, F2 and the soft cap into one pipeline: own stake → own vote, principals → delegated weight after decay, raw total → effective weight after saturation.

Two experiments worth running. Push the number of principals to 1,000 and watch the haircut climb—that is the soft cap refusing to mint a king, no matter how popular. Then set principals to zero and raise own stake to the maximum: a lone whale with 1,000,000 GT lands at v = 1,000—real influence, an order of magnitude short of control.

The rest of the machine

Formulas alone do not ship. Five mechanics complete the design:

• Proxies per policy domain. Independent delegations for treasury, parameters, grants. Undelegated weight stays silent—it neither votes nor counts toward quorum denominators.
• DAG invariant. Cycle attempts are rejected when the proxy is issued, and depth is capped at k_max = 2–3. LiquidFeedback’s decade of data shows longer chains simply go unused.
• Direct vote overrides. For any ballot the principal joins personally, their weight is subtracted from the delegate’s for that ballot. Revocation is instant.
• Commit–reveal balloting. While voting is open, the tally is invisible. A vote buyer cannot verify what was bought, so the bribe is unenforceable—this, plus revocability, is what actually closes the vote-market loop.
• Quorum on live weight. Thresholds count weight active in the last N epochs, not total supply—otherwise quorum dies as the dormant mass grows, which is precisely the failure mode documented across large DAOs in 2026.

Pitfalls: the attack table

Three of the six defenses are economic (F2, F3, F4), not procedural. That is the general lesson: procedural patches against governance attacks decay, because attackers iterate; incentive design has to carry the load.

Starting parameters

None of these are final numbers—they are priors to stress-test. Simulate the weight distribution on a synthetic delegation graph before fixing any of them: sensitivity to λ and α in particular decides whether your delegate set ends up looking like a parliament or an oligopoly.

Where this has been tried

LiquidFeedback (the German Pirate Party’s platform) ran per-topic transitive delegation in production and remains the best empirical source on super-delegate concentration—the problem F1 and the soft cap exist to price in. Google Votes ran liquid democracy over a corporate social graph for three years. On-chain, Polkadot OpenGov is the closest live relative with per-track delegation and conviction multipliers; Compound, ENS and Optimism run the single-level, non-transitive minimum; Cardano’s Project Catalyst professionalizes the delegate role with dReps. The open problems are real: sybil-resistant identity without excluding pseudonymous participants, formalizing “voted against instructions” tightly enough to slash on it, and the privacy–accountability boundary between secret principal ballots and public delegate records. Design for revision—every parameter above should be governable by the very mechanism it configures.