How Restaking and EigenLayer AVS Shared Security Work
How Restaking and EigenLayer AVS Shared Security Work
Someone at my office kept telling me restaking was “free extra yield on ETH you already staked.” That sentence is where most people get it wrong, and I was one of them.
By the end of this page you’ll have a plain map of how restaking and EigenLayer AVS shared security work — the three roles involved, why the same deposit gains more ways to get slashed, and whether the “shared security” story is actually safe. I’m a Korean office worker with no CS degree, not a validator operator, so I’ll keep the whitepaper vocabulary out of it.
Here’s my plan: I’ll walk the mechanics slowly, then run the honest debate on systemic risk, tell you where my own mental model was wrong, and hand you a checklist to think through before you ever touch it. Frameworks, not forecasts. No token to buy here, no yield ranking.
The one sentence that fixed my mental model
Restaking re-uses your already-staked ETH to secure additional services. That’s it. The same collateral that backs Ethereum now also promises to behave for other systems.
Read that again, because the risk hides inside it. If your ETH promises to behave in more places, it can now misbehave in more places. More jobs for the same deposit means more ways to lose part of it.
The extra reward you hear about is not a bonus. It’s payment for taking on extra slashing conditions. Once I saw the yield as compensation for stacked risk rather than a gift, every confusing headline suddenly made sense.
If the word “slashing” is fuzzy for you, pause here and read how proof-of-stake slashing works first. It’s single-layer slashing stacked on itself. Skip the base layer and none of this lands.
Why does re-using ETH even work? Because the security of any staking system is just the size of the bond you’d lose for cheating. If your ETH is bonded and can be slashed, that same bond can promise the same threat to a second system — as long as both systems can actually reach in and slash it. That’s the machinery that lets multiple systems share one bond. Elegant, and exactly why the failure modes correlate: they’re all pointed at the same pile of collateral.
Base staking, so restaking has something to sit on
Ethereum runs on proof of stake. Validators lock up ETH as a bond, propose and attest to blocks, and earn rewards for honest work. If they break the rules, the network burns part of that bond. That burn is slashing.
The bond does one job: it makes lying expensive. You can read the neutral background on proof of stake on Wikipedia if you want the textbook version.
Most people don’t run a validator themselves. They use a liquid staking token, or LST, like stETH. You deposit ETH, a service stakes it for you, and you get a token that represents your staked position and still moves around DeFi. Base staking secures one thing: Ethereum. It asks that same secured ETH to secure a second, third, and fourth thing too.
The three roles: restaker, operator, AVS
This is the part every explainer rushes. I’ll go slow, because the roles are the whole map.
Restaker. That’s you, if you opt in. You take staked ETH or an LST and register it through EigenLayer, signaling that your collateral is available to back extra services. You keep the upside and the downside.
Operator. Operators run the actual software for those extra services. Most restakers don’t run infrastructure, so they delegate their stake to an operator, the way you’d delegate to a validator. The operator does the work; your collateral backs their honesty.
AVS. An AVS is an Actively Validated Service — the thing buying security. Instead of bootstrapping its own validator set from scratch, it rents trust from ETH that’s already staked. EigenLayer is the coordinating smart-contract marketplace that connects restakers, operators, and AVSs. The canonical definitions live in the EigenLayer key terms docs.
Here’s the flow in one line: restaker delegates to an operator, the operator runs an AVS, and the AVS pays for the security the restaker’s ETH provides.
One detail I underrated at first: the operator is a real person or team with real uptime problems. My collateral doesn’t judge whether their server crashed or their code shipped a bug. If the AVS rules say the position gets slashed, it gets slashed. So the honesty I’m being paid for isn’t only mine — it’s the operator’s, and I’m insuring their competence with my bond. That reframed “delegation” from a passive click into a trust decision I’d want to make carefully.
Slashing for this went live on mainnet in April 2025, and it’s opt-in. Nobody re-stakes your ETH without you signaling it. That opt-in design is important: the risk only stacks on collateral you actively point at these extra jobs.
What an AVS actually is
“Service” sounds vague until you name them. AVSs are the plumbing that new blockchains and apps need but hate building from zero:
- Data availability layers (making sure block data is published)
- Oracles (feeding outside prices onto the chain)
- Bridges (moving assets between chains)
- Sequencers (ordering transactions for rollups)
- Off-chain compute and AI verification (checking work done elsewhere)
Rollups lean on several of these. If you’ve read my breakdown of zk-rollups vs optimistic rollups, the data-availability and sequencer pieces are exactly the kind of service an AVS can supply. Shared security is the sales pitch: don’t recruit your own validators, borrow Ethereum’s.
LST vs LRT vs restaking, untangled
I mixed these three up for a week, so here’s the table I wish I’d had.
| Term | What it is | What secures | Slashing exposure |
|---|---|---|---|
| Staked ETH | ETH bonded to a validator | Ethereum only | One set of rules |
| LST (e.g. stETH) | A token for staked ETH, usable in DeFi | Ethereum only | One set of rules |
| Restaking | Re-using that staked ETH via EigenLayer | Ethereum + each AVS you back | Stacks per AVS |
| LRT (liquid restaking token) | A token representing a restaked position | Ethereum + AVSs | Stacked, plus DeFi reuse |
An LRT sits on top of everything else. It’s a liquid token wrapping a restaked position, which itself wraps staked ETH. Convenient, and also the deepest end of the pool. Each layer adds a place where things can go wrong.
The pattern to hold in your head: every step up that table trades a bit more risk for a bit more capital efficiency. Nobody hands you efficiency for nothing.
The word people use for this reuse is capital efficiency, and it sounds like a pure win. Idle ETH doing more work — who could argue? The quiet part is that efficiency and safety pull in opposite directions here. The more places your one deposit works, the fewer places you can afford any of them to fail. That’s the trade nobody prints on the label, and it’s the whole reason I stopped reading it as a yield product and started treating it as a risk product that happens to pay yield.
Is restaking a systemic risk? The honest debate
This is where the top search results go quiet and tilt toward “opt in here.” I won’t. Here are both sides, and I mean both.
The bull case: shared security is genuinely useful
New services need a trusted validator set on day one. Building one is slow and fragile — a young network with a thin, cheap-to-attack bond is a soft target. Renting Ethereum-grade security instead is a real solution to a real problem.
Pooled security also means idle capital does more work. A large pool of staked ETH sits there securing one chain. Letting it back useful infrastructure isn’t obviously wasteful. The bull case isn’t hype; it’s a legitimate design that lowers the barrier for honest new services.
There’s a version of this I find genuinely convincing. A small team building, say, an oracle shouldn’t have to also solve the multi-year problem of recruiting a large, honest, well-funded validator set before their product can be trusted. That requirement has killed useful ideas. Shared security lets a team rent trust on day one and focus on the actual service. For the person who just wants correct prices on a chain, that’s a real improvement, and I don’t want to wave it away to sound cautious.
The bear case: correlated slashing and rehypothecation
Now the other side. When your one deposit backs many AVSs, the slashing conditions don’t just add up — they can fire together. Ethereum co-founder Vitalik Buterin warned about exactly this in Don’t overload Ethereum’s consensus. His worry: pulling ETH’s security into many outside jobs can drag consensus-layer risk into places it was never meant to reach.
Cascading, or correlated, slashing is the sharp edge. Picture a bad update, a shared bug, or one operator failing across several AVSs at once. A single event slashes many positions together, and losses concentrate instead of spreading out.
Then add LRTs used as collateral elsewhere in DeFi. A restaked position gets wrapped, lent, and borrowed against, stacking claims on the same underlying ETH — a pattern people compare to the rehypothecation chains behind 2008. When that ETH also secures a validator, you get a related risk I wrote about in how MEV extraction works: pressure piling onto the same consensus layer from several directions.
Rehypothecation is a scary-sounding word for a simple, familiar thing: the same asset promised to more than one party at once. It’s fine right up until everyone tries to claim it in the same moment. If an LRT is collateral for a loan, and that LRT wraps ETH that’s also securing an AVS and the base chain, then one bad slashing event doesn’t stay contained. It can ripple into the lending market that trusted the LRT’s value. The “too big to fail” worry here isn’t that any single piece is reckless. It’s that the pieces are quietly wired together, and correlation is invisible until it isn’t.
Where I actually land
I don’t resolve this, and I won’t predict where it goes. The mechanics are real and the risk is real, and they’re the same sentence. My honest position: shared security solves a genuine bootstrapping problem, and the correlated-slashing concern is serious enough that I treat it as an advanced move, not a default one. If someone frames it to you as free yield, they’ve skipped the entire bear case.
Where I was wrong
My first model was “more yield for the same ETH — why wouldn’t everyone do this?” I treated the extra reward as a coupon stapled onto staking. Free money, basically.
Two things broke that model. First, once I traced the roles, I realized I wouldn’t be running the software — an operator would, and my collateral would answer for their mistakes. I’d be trusting a stranger’s uptime and code with my bond. That’s not passive.
Second, I’d been counting the reward without counting the new slashing conditions attached to it. When I lined them up, the yield stopped looking like a bonus and started looking like an insurance premium I was collecting for taking on tail risk. Sometimes that trade is fine. But “free” was just me not reading the fine print.
The last thing I got wrong: I assumed the EIGEN token clearly captured all this value. It doesn’t, at least not provenly. There’s a fee model discussion (ELIP-12, buybacks) and a work/governance role, but whether that reliably accrues value is unproven. I’d stopped treating an open question as open. So now I hold it as one.
A pre-checklist, not a recommendation
I’m not telling you to restake or to avoid it. I’m giving you the questions I’d want answered before the topic is even on the table. This is the framework I use to think about the risk.
- Do I actually understand single-layer slashing? If not, that’s the prerequisite, not this.
- For each AVS backed, what exactly gets slashed, and under what conditions?
- Which operator holds the delegated stake, and what’s their track record?
- If several AVSs failed at once, how correlated would my losses be?
- Is my position wrapped in an LRT that’s then reused as DeFi collateral? How many layers deep?
- Am I being paid for risk I understand, or for risk I’m ignoring?
If you can’t answer these in plain language, the honest move is to keep learning, not to opt in. This model rewards people who read the conditions and punishes people who chase the headline number.
FAQ
What is restaking in crypto, and how is it different from normal staking? Normal staking bonds ETH to secure Ethereum and earns rewards. It re-uses that same bonded ETH to secure additional services through EigenLayer. Same deposit, more jobs, and more slashing conditions attached to it. The extra reward pays for the extra risk.
What is an AVS in EigenLayer? AVS stands for Actively Validated Service — any service that buys pooled security instead of building its own validator set. Examples include data availability layers, oracles, bridges, sequencers, and off-chain compute. EigenLayer is the marketplace connecting these services to restakers and operators.
What is the difference between an LST and an LRT? An LST (liquid staking token, like stETH) represents plain staked ETH and still moves in DeFi. An LRT represents a restaked position — staked ETH that also backs AVSs. The LRT carries more layers of exposure because it sits on top of both those layers at once.
Is restaking safe? What is cascading slashing risk? It stacks slashing conditions on one deposit, so it carries more risk than base staking. Cascading, or correlated, slashing is the concern that one event — a shared bug or a failing operator — could slash many AVS positions at once, concentrating losses instead of spreading them. Treat it as advanced, not default.
What does the EIGEN token actually do? EIGEN is described as a work and governance token, with a fee-model discussion (ELIP-12, buybacks) around value accrual. Whether it reliably captures the value flowing through the system is unproven. I treat that as an open question rather than a settled answer, and I don’t price-forecast it.
Why did Vitalik Buterin warn against overloading Ethereum’s consensus? In a 2023 post, Vitalik argued that pulling Ethereum’s staked security into many outside services risks dragging consensus-layer risk into places it wasn’t designed for. His concern is that correlated failures could threaten the base chain everyone depends on, not just the extra services.
seonjae — Korean office worker documenting his transition into AI systems, agents, and vibe coding — without a CS background. Shipping in public.
Next in this Framework Deep Dive series: I’ll trace a real delegation on a block explorer — following one deposit from staked ETH to operator to AVS — so you can see the roles on-chain instead of in a diagram.
