Lightning Labs has published LayerTree, a Bitcoin scaling design that attempts to let large groups of users share a single UTXO while preserving individual exit rights. Instead of placing each participant’s balance in a separate on-chain output, LayerTree stores balances in an off-chain Merkle-sum tree and commits only its root to Bitcoin.
The LayerTree technical paper, authored by Lightning Labs co-founder and CTO Olaoluwa Osuntokun, describes a covenant-controlled output whose spending rules verify changes against that committed root. A member can unilaterally remove its balance in one Bitcoin transaction without requiring signatures from the operator or other members, pre-signed transaction trees or an expiry for the shared output itself.
The operator can coordinate joins, payments and cohort maintenance, but does not hold a key capable of spending users’ balances. Individual positions can carry leases that eventually allow the operator to evict them, although an eviction must pay the member’s full balance to its designated exit key. LayerTree therefore separates operator coordination from custody of the underlying Bitcoin.
Shared UTXO Design Compresses On-Chain Footprint
The paper’s primary measured configuration uses a depth-16 tree with 65,536 available positions. In that setup, a unilateral exit occupies roughly 1,020 virtual bytes regardless of whether the tree contains only a few users or fills all 65,536 slots, because transaction size depends on tree depth rather than total active membership.
Lightning Labs compares that result with a modeled radix-2 transaction-tree exit representing an Ark or CTV-style structure. At the same depth, that model reaches about 2,511 vB, although the comparison deliberately excludes anchors and fee children, which makes the transaction-tree case more favorable. The figure is therefore a design-model comparison, not evidence that LayerTree has already outperformed a live Ark deployment.
Joining can become substantially cheaper when users enter in large cohorts. A single member costs about 937 vB in the paper’s dense join model, while an estimated 1,024-member graft costs roughly 614 vB in total, or around 0.6 vB per member. That efficiency comes from committing an already constructed subtree rather than adding hundreds of separate Bitcoin outputs. The larger-cohort figures are extrapolated from measured smaller joins.
Most payments are intended to avoid the chain entirely. LayerTree supports signed vouchers and channel leaves, with Bitcoin transactions primarily used for membership changes, settlement and enforcement of exit rights. Vouchers can be delivered through store-and-forward when a recipient is offline, although the paper describes specific trust and timing constraints around Lightning reception. Offline receiving is therefore a feature of defined payment flows rather than an unconditional property of every LayerTree transfer.
That approach connects LayerTree to continuing development around Bitcoin payment infrastructure. Lightning has recently been integrated into the x402 machine-payment standard, extending Bitcoin settlement into automated payment workflows. LayerTree differs by focusing on how ownership and exit rights can be compressed into shared Bitcoin outputs rather than primarily on payment routing.
Consensus Changes Keep LayerTree Off Mainnet
The largest constraint is Bitcoin itself. None of LayerTree’s four documented opcode tiers can run under today’s Bitcoin consensus rules. The smallest construction uses OP_CAT and OP_TWEAKADD, while fuller variants add transaction introspection, signature-over-data or contract-verification functionality that remains proposed rather than activated.
The project already includes more than a conceptual white paper. Lightning Labs says the accompanying work includes a Go implementation, simulator, thousands of executable checks and formal verification of the transition rules in Lean 4. However, the project’s own documentation notes that formal verification of the covenant rules does not establish production readiness for the complete off-chain protocol, whose broader ordering and timing model remains unfinished.
Bitcoin infrastructure investment continues to extend beyond Lightning itself, with companies also backing payments, custody and other Bitcoin-native infrastructure. LayerTree adds another direction to that work: sharing UTXOs more efficiently without converting the operator into a custodian.
For now, LayerTree is best understood as a researched scaling architecture with working reference code, not a new Bitcoin layer that users can access today. Its eventual viability depends not only on its measured efficiency and security model, but on whether Bitcoin developers and the wider ecosystem ever converge on the consensus changes required to make its covenant design executable on mainnet.