How do EigenLayer, Symbiotic, and Karak keep a slash on one service from spreading to others? This shared security restaking comparison breaks down unique stake, vault-level isolation, and DSS caps, plus where the economics still hurt restakers, why Karak’s 2026 pivot to OpenGDP is a risk signal, and key questions to ask before depositing collateral.

How do EigenLayer, Symbiotic, and Karak keep a slash on one service from spreading to others? This shared security restaking comparison breaks down unique stake, vault-level isolation, and DSS caps, plus where the economics still hurt restakers, why Karak’s 2026 pivot to OpenGDP is a risk signal, and key questions to ask before depositing collateral.
A shared security restaking comparison of EigenLayer, Symbiotic, and Karak's slashing-isolation models is only useful if it goes past "here's how slashing works" and into "here's what happens to your collateral when it doesn't." This post builds that comparison: how each protocol scopes a penalty to the service that triggered it, where the economics of shared collateral can still work against a restaker even when isolation holds, and why Karak's 2026 pivot away from restaking is itself a risk signal worth weighing alongside the slashing mechanics on paper.
Shared security restaking lets one pool of staked capital secure multiple independent services at once. That only works if a penalty against one service cannot bleed into the others. Slashing isolation is the set of rules that decide whether a bad outcome on Service A stays contained to Service A, or spreads to restakers who never touched it.
Slashing in restaking is the forced loss of a portion of staked or restaked collateral after an operator misbehaves on a specific service, such as signing a fraudulent message, going offline during a required duty, or double-signing. The service that defines the misbehavior, an AVS (Actively Validated Service) on EigenLayer, a network on Symbiotic, or a DSS (Distributed Secure Service) on Karak, is also the entity that decides when a slash fires.
EigenLayer makes this explicit. According to Kiln's writeup on EigenLayer's 2025 rewards v2 and slashing rollout, "EigenLayer does not enforce specific guidelines or standard logic for slashing." The protocol itself does not make the call; each AVS independently determines when to enable slashing and applies it against the operator sets allocated to it.
Can a slashing penalty on one AVS spread to other services an operator secures? In a poorly isolated design, yes, and that cascading risk is exactly the problem shared security architecture exists to prevent. If an operator stakes one undivided pool of ETH across five services and one of those services misjudges a slash, the other four services' restakers absorb losses for a fault they had no part in and no visibility into.
This is why all three protocols covered here, despite real differences in mechanics, converge on the same design goal: scope the blast radius of a slash to the stake that was actually exposed to the misbehaving service, and nothing more.
Isolating a slash to the right service solves the contagion problem, but it doesn't solve the pricing problem underneath restaking's economic model. The same unit of capital can be allocated across several services simultaneously, which means a restaker's total tail risk is the sum of every service it touches, even when no single slash can legally reach more than its allocated share. A restaker who spreads collateral across five AVSs has five independent chances of a loss event in a given period, not one, and the extra yield on offer for each additional service rarely scales with that compounding exposure.
There's also an incentive problem on the service side. An AVS, network, or DSS that wants to attract operators has a reason to set its slashing terms as lenient as it can justify, since harsher terms make the service less attractive relative to competing services bidding for the same operator capital. Isolation protects other services from one AVS's bad judgment, but it does nothing to stop that AVS from under-pricing its own slashing risk in the first place. EigenLayer's total value locked is a visible symptom of this repricing: it ran to a roughly $20B peak in 2024 on points-farming speculation and had fallen to roughly $5.0B by July 2026 once points campaigns ended and real slashing went live, per Protofire's 2026 restaking comparison.
Restaking takes capital already staked for one purpose, usually securing a base layer like Ethereum, and re-commits it to secure additional services without withdrawing it first. The restaker keeps earning the base staking yield and picks up additional rewards for the extra services secured, in exchange for new slashing exposure.
Three roles repeat across every shared security design:
Liquid restaking tokens (LRTs) sit on top of this structure as a convenience layer: a protocol pools many restakers' deposits, delegates to a curated set of operators, and issues a tradable receipt token. LRTs do not change the underlying slashing isolation model; they just add another layer of operator-selection risk on top of whichever protocol holds the actual collateral.
The services restaked capital secures today are mostly infrastructure a chain or app needs but can't bootstrap its own validator set for cheaply: data availability layers, oracle networks that need crypto-economic skin in the game behind their price feeds, cross-chain bridges that need an economic penalty for signing a fraudulent message, and keeper or automation networks that execute time-sensitive transactions on a protocol's behalf. In each case, the service would otherwise have to recruit and bond its own independent validator set from scratch, which is slow and capital-intensive for a young project.
The use cases under active discussion for the next wave look similar in shape but higher-stakes: shared security for rollup sequencers and shared decentralized sequencing sets, and app-specific or appchain security markets where a new chain rents crypto-economic security instead of recruiting its own validator set at launch. None of that changes the core question this post is built around: whichever service a restaker's capital ends up securing, the slashing terms attached to that specific allocation are what determines the downside.
EigenLayer isolates slashing by letting an operator split, rather than pool, the stake it commits to each AVS it secures.
Under EigenLayer's current design, operators allocate specific portions of their staked security to individual AVSs as "Unique Stake," and only that AVS can slash the portion allocated to it. Eigen Labs describes the mechanism directly: "Operators can allocate specific portions of their staked security as 'Unique Stake,' ensuring that only one AVS has the ability to slash that stake."
Operator sets formalize this further by grouping an operator's allocations per AVS, so a slashing decision from AVS X can only reach the stake X was actually allocated, not the operator's full restaked balance across every other AVS it serves.
Put a number on it to see why that matters: say an operator restakes 100 ETH and allocates 30 ETH of Unique Stake to AVS A and 70 ETH to AVS B. If AVS A's slashing logic misfires and penalizes a validator for a fault that didn't happen, the maximum exposure is the 30 ETH allocated to AVS A. The 70 ETH backing AVS B is a separate allocation under EigenLayer's accounting and is not reachable by AVS A's slasher, regardless of how severe that AVS's penalty is. That is the practical payoff of Unique Stake: a misconfigured or malicious AVS can only ever burn through the slice it was handed, not the operator's full restaked balance.
For readers who want the fuller mechanics of AVSs, operators, and services like EigenDA, QuillAudits' EigenLayer restaking explainer covers the base architecture this comparison builds on.
A slashed stake has to go somewhere, and where it goes changes who bears the economic cost of a fault. It's tempting to assume a protocol this mature has moved on to routing slashed funds toward an injured party or an insurance pool, but EigenLayer's own mechanics say otherwise. Per Kiln's coverage of the 2025 rewards v2 and slashing release, "slashed funds are permanently locked by sending them on a 'dead' address (token burn)" for ERC-20 collateral, which makes the slashed value irretrievable rather than redirected to anyone. There is no AVS-configurable redistribution path in that mechanism; burn is the outcome. Anyone evaluating an AVS should read its specific slashing documentation rather than assume a recipient exists for a penalty that, on EigenLayer's current design, simply destroys the value instead.
Symbiotic takes a more modular approach: instead of one operator splitting stake across many services from a single balance, Symbiotic separates collateral into discrete vaults that each network and operator relationship is built around individually.
Symbiotic's architecture separates restaking into three parts, according to Symbiotic's own documentation on vault structure: vaults that hold collateral, networks that are the services being secured, and operators that perform validation. Each vault sets its own slashing rules, decides which networks it secures, and chooses which operators it delegates to.
Because the vault, not the restaker or a protocol-wide pool, is the unit that carries slashing terms, two restakers depositing the same token into two different vaults can end up with entirely different slashing exposure, depending on which networks each vault opted to secure and what penalty terms it negotiated with them.
Symbiotic's core Slasher module validates and executes a penalty in a single step, with no dispute window before funds move. Which variant a vault uses is a deliberate trade-off: instant slashing removes any chance to catch a mistaken or malicious slash request before it executes, while a veto window adds a safety check at the cost of delaying the penalty.
Symbiotic also bounds how far back a slash can reach. This caps the lookback period rather than leaving stake slashable indefinitely.
Re2 and Symbiotic extended this isolation logic into Slashing Insurance Vaults (SIVs), modular vaults that split delegator capital into junior, mezzanine, and senior tranches so that losses from a slash are absorbed in order, with junior-tranche depositors compensated with higher yield for taking the first loss. As Re2 and Symbiotic put it, "while slashing events are rare, their impact can be devastating and disproportionately affect smaller participants." Tranching is a direct response to that asymmetry: it gives restakers a way to choose their position in the loss-absorption order instead of sharing an undifferentiated risk pool.
Karak's slashing model reads similarly to EigenLayer's on the surface, operators allocate vaults to specific services, and only the allocated portion is exposed, but Karak adds explicit, on-chain caps and timing windows around how far a DSS can reach.
In Karak, operators allocate specific vaults to a DSS, and only the vaults an operator has staked into that particular DSS are eligible to be slashed by it, according to the protocol's own documentation. Three guardrails sit on top of that allocation:
| Guardrail | Mechanic |
|---|---|
| Cooldown | Slashing requests are subject to a two-day cooldown per operator before they can execute |
| Veto | A slashing committee holds veto rights over a request it judges unfair |
Karak also builds a specific defense against withdrawal front-running: stakers face a minimum nine-day withdrawal delay, combining the withdrawal window and the veto window, and a DSS can still slash misbehavior that occurred up to seven days before a withdrawal was initiated.
To see why the retroactive window matters, walk through a timeline: an operator misbehaves on day 0, then immediately initiates a withdrawal on day 1 hoping to exit before anyone notices. Because a DSS can still reach back seven days from the withdrawal request, and the withdrawal itself does not clear for roughly nine days under the combined withdrawal and veto windows, the misbehavior on day 0 stays slashable for the entire time the withdrawal is pending. That sequencing is what closes the obvious exploit where an operator spots a coming slash and tries to withdraw before it lands.
What happens to restaked funds if a restaking protocol shuts down or pivots away from restaking entirely? Karak is the live answer.
The OpenGDP site lists Karak's V1 Staking, V2 Staking, and K2 Bridge under a "Legacy" heading rather than presenting them as the current product. Protofire's 2026 restaking comparison describes the shift as "a rebrand toward real-world-economy infrastructure with no restaking, K2, or DSS messaging", and notes that Karak's TVL collapsed from its 2024 peak.
That sequencing matters for anyone reading a slashing-mechanics writeup and treating it as a permanent spec. A DSS cap, a cooldown window, and a veto committee are a sound design on paper, but they describe a product whose own team has relabeled it "Legacy" and walked toward an unrelated business. Evaluating "which slashing model is safest" without also asking "will this protocol still be operating this product in a year" leaves out half the risk.
EigenLayer isolates slashing by operator-level unique stake allocation to each AVS, Symbiotic isolates it at the vault level with network-defined terms, and Karak isolates it by DSS-scoped vault allocation with on-chain caps and cooldowns, but the three diverge sharply on who holds dispute rights and how durable the protocol itself has proven to be.
| Dimension | EigenLayer | Symbiotic | Karak |
|---|---|---|---|
| Isolation unit | Unique Stake per operator set, scoped to one AVS | Vault, scoped to the networks and operators it chooses | Vault allocated to a specific DSS |
| Who sets slashing terms | Each AVS independently | Each vault, per network | Each DSS, within a protocol-set ceiling |
| Dispute mechanism | AVS-defined (varies by AVS) | Instant Slasher (no dispute) or VetoSlasher (resolver veto window) | Two-day cooldown plus slashing-committee veto |
| Slashed-fund destination | Burn, sent to a dead address; no AVS-configurable redistribution path | Network/vault-defined | Protocol-defined, subject to the DSS's capped percentage |
| Extra risk-tranching option | Not a native primitive | Slashing Insurance Vaults (junior/mezzanine/senior tranches) | Not a native primitive |
| Approximate TVL (2026) | ~$5.0B as of July 2026, down from a ~$20B 2024 peak | Not disclosed in the sources used for this post | Collapsed from its 2024 peak; no active slashing deployed |
| Protocol direction (2026) | Continues as a restaking-first protocol | Continues as a restaking-first protocol | Rebranded to OpenGDP; restaking demoted to "Legacy" |
Is EigenLayer or Symbiotic safer for restaking? Neither has a categorical edge. EigenLayer's unique-stake model gives an operator finer-grained control over exactly how much is exposed to each AVS, while Symbiotic's vault model gives the restaker more say upfront, since they choose a vault for its specific network and slashing terms rather than trusting an operator's allocation decisions after the fact. The better fit depends on whether you'd rather vet an operator's allocation discipline or a vault curator's network and slasher choices.
Slashing isolation only protects against contagion between services; it says nothing about concentration within a single layer of the system. Symbiotic's vault model hands a small curator team the decisions that actually define a restaker's risk, which networks a vault secures, which operators it delegates to, and whether it runs an instant or vetoed slasher, so depositing into a vault is really a bet on that curator's judgment rather than on Symbiotic's protocol code. Karak's slashing committee and Symbiotic's VetoSlasher resolvers introduce the same kind of trust concentration from a different angle: a small, often multisig-controlled group holds the power to block a slash, which protects restakers from a bad-faith penalty but also means the veto itself is a single point of failure if that group's signing keys are compromised or its membership never rotates. A restaker base this concentrated can also mean that a problem with one widely-used operator or curator ripples across many nominally separate vaults or AVSs at once, which is the same cascading-risk pattern slashing isolation was built to stop, just moved up a layer.
Before committing collateral to any shared security restaking design, work through these questions regardless of which protocol you're evaluating:
That last question is not hypothetical. It is the exact question Karak's OpenGDP transition answers the hard way.
Slashing mechanics on paper describe what a protocol's contracts are supposed to do. They don't tell you whether the deployed contracts match that design, or whether an operator's composition and behavior has drifted since you first vetted it. A point-in-time audit catches the first problem; QuillAudits' layered protocol-security framework is a reasonable checklist for what to vet beyond slashing mechanics alone before any collateral moves, including the governance keys behind a vault or AVS, which are frequently multisig-controlled and worth checking against QuillAudits' guide to multisig security habits that actually matter.
An audit alone doesn't catch the second problem, drift after launch. QuillAudits has argued elsewhere that a one-time audit isn't enough precisely because continuous security monitoring is needed to catch changes introduced after a contract goes live, and that logic applies directly to restaking, where operator sets, vault compositions, and DSS configurations all change after the initial deposit. The same on-chain monitoring approach teams use to watch a contract's state for anomalies applies just as well to watching an operator's uptime and signing behavior over time.
Not all shared security restaking protocols are built the same, and as Karak's 2026 pivot shows, not all of them stay restaking protocols either. Reading the slashing mechanics is necessary. Checking whether the protocol enforcing them is still committed to the business is the part too many comparisons skip.
Contents

From day-zero risk mapping to exchange-ready audits, QuillAudits helps projects grow with confidence. Smart contracts, dApps, infrastructure, compliance: secured end to end.