What restaking is, and the risk nobody likes to mention

Restaking is the most consequential idea to come out of Ethereum staking since the Merge, and one of the least scrutinized. The pitch is elegant: capital that already secures the base layer sits there as latent collateral, so why not let it secure other things too? Point your staked ETH at additional protocols, accept additional slashing conditions, earn additional yield. In one move, Ethereum's economic security stops being a single-purpose asset and becomes a reusable, rentable resource. For a team that needs a trust network but cannot bootstrap billions in fresh stake, that is close to a superpower.

There is a structural fact the marketing decks skip past. When one pool of collateral simultaneously backs many independent services, the failures of those services stop being independent. A design that improves capital efficiency by sharing security also shares fate. The thesis here is simple and uncomfortable: restaking is genuinely useful and probably here to stay, but by concentrating operators, collateral, and slashing exposure onto the same base, it threads correlated, systemic risk through DeFi. Understanding that risk, and how the sector is trying to engineer around it, is now part of any serious read on Ethereum's security economics.

How restaking actually reuses security

Start with ordinary staking. To validate Ethereum you post ETH as a bond and run a validator. Follow the rules and you earn issuance and priority fees; break them and part of your bond is slashed. That bond is the whole point. It makes attacking the network expensive because misbehavior burns your own capital. And most of the time the capital just sits there as a threat, doing security work by existing rather than by moving.

Restaking, in the EigenLayer model, lets you opt that same bond into extra duties. You take staked ETH, or a liquid staking token representing it, and commit it as collateral to one or more Actively Validated Services, or AVSs. An AVS is any system that needs its own cryptoeconomic security but does not want to raise a native token and recruit a fresh validator set: a data-availability layer, an oracle network, a bridge, a cross-chain messaging protocol, a fast-finality or pre-confirmation service, a zk-coprocessor. Rather than bootstrap trust from zero, the AVS rents it from restakers, who run its software and accept its slashing conditions in exchange for a fee.

The plumbing is worth naming, because the risk lives in it. A restaker sets withdrawal credentials so a smart-contract layer can enforce penalties against the underlying stake, then delegates to an operator who actually runs the AVS node software. Each AVS defines its own tasks and its own slashing logic. A single operator, backed by a single pool of restaked ETH, might therefore attest for an oracle, sign for a bridge, and serve data availability at the same time, with each of those services able to independently penalize that same collateral if the operator faults on that specific duty. One bond, many masters, many knives pointed at it.

The efficiency gain, and where the risk hides

The upside is easy to see. From the ecosystem's vantage, restaking recycles Ethereum's deep pooled security instead of fragmenting fresh capital across dozens of thin, easily corrupted token economies. A new protocol that would otherwise launch with a small validator set someone could bribe or overpower can instead inherit a slice of a large, battle-tested security base on day one. For stakers, it is extra yield on capital they were already committing. For the market, it turns security into something priced and allocated rather than wastefully duplicated.

The risk hides in the word shared. In classic staking, failure modes are largely independent: a bug in one small protocol slashes that protocol's validators and touches no one else. In a restaked world, the same operators and the same collateral are load-bearing across many services simultaneously. That produces several distinct hazards worth separating:

• Collateral concentration. If most restaked ETH flows to a handful of large operators, those operators become systemically important. A single bug, key compromise, or malicious act at one of them can slash collateral that was backing many unrelated AVSs at once.
• Correlated slashing. Because one operator's misbehavior can trip penalties across every AVS it serves, losses that used to be isolated can arrive together and reinforce each other instead of averaging out.
• Opaque, stacked conditions. A restaker inherits slashing rules written by many independent teams of wildly varying quality. Your real risk surface is the union of every AVS you opt into, and no individual can realistically audit all of it.
• Yield-chasing pressure. Fees push operators and restakers to secure ever more AVSs, which is exactly the behavior that raises correlation, because at the margin saying yes to one more service is nearly free.

None of this is exotic. It is the direct, predictable consequence of letting one bond back many obligations. The efficiency and the fragility come from the same design decision, which is why you cannot optimize one away without touching the other.

Cascading slashing, conceptually

The scenario that worries careful people is a cascade. Picture a large operator serving many AVSs with a deep pool of restaked and delegated ETH. A subtle bug in one AVS's slashing logic, or a genuine operator fault, triggers a large penalty. That penalty does not just hurt the operator; it burns collateral other AVSs were also counting on. If the same collateral was effectively double-counted as security across several services, each of them just got weaker at the same instant, through no fault of their own. The security they thought they had rented partly evaporated in an event they had no part in.

Now add the human and market response. Restakers who see an operator take a hit rush to withdraw or redelegate. Liquid restaking tokens tied to that operator or AVS wobble, and because those tokens are used as collateral elsewhere in DeFi, even a modest discount can trip liquidations that force more selling. Withdrawal queues and unbonding delays mean people cannot exit as fast as they want, which converts a price move into a scramble for the door. The initial slashing event, small in isolation, propagates through shared collateral and shared operators into something the whole restaking layer feels. It is a bank-run-shaped risk wearing a cryptoeconomic costume: nothing is technically insolvent, but everyone tries to be first out at once.

Sharing security means sharing fate: the same design that lets one bond back many services also lets one failure ripple across all of them.

Two caveats keep this honest. This is a conceptual model, not a prediction of magnitudes; whether a real cascade stays contained or turns systemic depends on how much collateral is genuinely shared versus segregated, how correlated the dominant operators are, and how aggressive the slashing conditions are. And well-designed systems work hard to make catastrophic, network-wide slashing require deliberate, provable, high-threshold misbehavior rather than an ordinary operational hiccup like a missed attestation or a brief outage. The claim is not that collapse is inevitable. It is that the correlation channel exists by construction and has to be actively managed rather than assumed away.

Liquid restaking tokens: leverage on top of leverage

Most users will never run an operator or hand-pick AVSs. They will hold a liquid restaking token, or LRT, issued by a protocol that pools deposits, delegates to operators, selects a basket of AVSs, and hands back a single tradable token representing the whole position. LRTs are to restaking what liquid staking tokens were to staking: a convenience layer that abstracts away the hard parts and, in the same motion, hides where the risk actually lives.

Trace the stack of claims that can sit on one unit of ETH. The ETH secures Ethereum. A liquid staking token represents that staked ETH. That token is restaked to secure several AVSs. An LRT wraps the restaked position into one asset. The LRT is supplied as collateral to a lending market, borrowed against, and the proceeds are looped back in for more exposure. Each layer, examined alone, is reasonable. Stacked, they mean a single slashing event or de-peg near the bottom can cascade upward into liquidations at the top, while the person holding the LRT may have almost no visibility into which AVSs and operators they are ultimately exposed to, or how much leverage sits above and below them.

Why the abstraction is dangerous, not just convenient

The core problem is that an LRT standardizes a token while the risk underneath stays heterogeneous. Two LRTs can trade as if interchangeable while pointing at very different operator sets and AVS baskets with very different slashing exposure. If issuers compete on headline yield, the natural way to win is to opt into more or riskier AVSs, which is precisely the behavior that raises systemic correlation. And because LRTs are designed to be used as DeFi collateral, they wire the restaking layer straight into lending markets, so trouble in restaking no longer stays in restaking. Anyone treating an LRT as equivalent to plain staked ETH is mispricing a materially different, more layered risk. This is not financial advice, but it is a reason to read what an LRT actually holds before treating its yield as free.

How the sector is trying to engineer around it

The people building this are not blind to the problem, and much of the frontier work in restaking is really risk-engineering wearing a product label. The most important shift is toward attributable, targeted slashing: penalties scoped to a specific AVS and a specific fault rather than draining an operator's entire multi-service position. If a fault in one AVS can only slash the stake allocated to that AVS, the correlation channel narrows sharply, because a failure over here stops automatically bleeding collateral that was securing over there. This is the difference between a firewall and an open-plan floor.

Several other levers are in play, and they are worth knowing by name because they are how you judge whether a given restaking system is actually safer or merely marketed that way:

• Unique or segregated security. Letting an AVS require dedicated collateral instead of sharing a pool with every other service, trading some capital efficiency back for isolation.
• Operator and stake caps. Limiting how much of the network any single operator can control, and how heavily any one AVS can lean on the shared pool, to blunt concentration.
• Veto and delay mechanisms. Security councils, challenge windows, or timelocks so a large or unusual slashing event can be reviewed and reversed before it becomes irreversible.
• Conservative, well-audited slashing conditions. AVSs designing penalties that fire only on provable, deliberate misbehavior, keeping ordinary operational faults out of catastrophic territory.
• Transparency at the LRT layer. Disclosing operator sets, AVS baskets, and effective risk so the token is not an opaque wrapper over unknown exposure.

The honest reading is that these are mitigations, not solutions, and each one taxes the very thing that made restaking attractive. Segregated security fragments the pool. Caps cap the yield. Veto councils reintroduce trusted humans into a system that was supposed to be trustless, and a council that can reverse a slashing can, in principle, be captured or pressured. The sector is feeling out an equilibrium between how much security to share and how much fate to share with it, and that equilibrium has not settled. Watch which trade-offs a protocol actually makes in its contracts and parameters, not which ones its landing page mentions.

The bottom line

Restaking earns its reputation as an important primitive. It turns Ethereum's dormant security into a productive, rentable resource, lowers the barrier for new protocols to launch with real cryptoeconomic backing, and gives stakers a way to earn more on capital they had already committed. Those benefits are real, and they are why so much capital arrived so fast. Dismissing restaking as pure risk would be as lazy as pretending it carries none.

But the same mechanism that makes security capital-efficient makes failures correlated, and the LRT layer stacked on top can turn a local slashing event into a market-wide one. The risk nobody likes to mention is not a single bug; it is the structural fact that shared collateral and concentrated operators convert independent failures into joint ones, and that DeFi's habit of building leverage on leverage amplifies the result. For an advanced participant, the work is to look through the yield to the exposure underneath: which operators, which AVSs, which slashing conditions, and how much of your collateral is quietly securing several things at once. None of this is financial advice, and the magnitudes are genuinely uncertain. The task is to price the correlation honestly instead of pretending capital efficiency comes free.