This freshly crowned intent protocol closed an $84 million round this January. Its documentation promises “chain abstraction” — spend a dollar on Ethereum, have it settle on Arbitrum, Base, or any of a dozen networks, all without crossing a bridge UI, without a wrapped token in sight, without any user who can name the mechanism. The token is up 400% since announcement. The community threads are ecstatic.
The security model is where the poetry ends.
Seven multisig signers. A nested council of the same funds that led the seed round. An optimistic-fraud layer that, on two of the three connected ecosystems, delegates finality challenges to a governance body whose membership overlaps with the investor register. Relayers are run by a handful of service providers. The emergency pause is a one-line admin function that, should it ever need to run during an actual exploit, will run too late.
If you trace the full dependency tree — relayer network, verifier contracts, fallback policies, MEV bots monitoring the mempool — you converge on the same primitive that has drained more than $2.5 billion from this industry over the last four years: a custody arrangement between two ledgers, wrapped in increasingly expensive cryptographic fabric.
I have seen this cycle before. In 2017, I sat in a Baltic WeWork auditing whitepapers for an ICO platform. Out of forty reviewed, thirty-two failed basic viability tests. The names were different. The architecture of hope was identical.
This is my third bridge cycle. I watched Ronin lose $625 million while Axie’s players absorbed the insolvency. I watched Wormhole’s $326 million exploit get quietly refinanced by a parent company rather than a protocol. I watched Nomad’s $190 million drain in ninety minutes — a cloned, trusted root that let any passerby replay the exploit for themselves. I watched Harmony Horizon lose $100 million and then disappear into a governance twilight. I sat through the post-mortems, the committee calls, the token reissues, the shell of recovery plans.
The industry’s response has been ritualized: audit, bug bounty, “security council,” then a cleverer architecture. In 2021, we promised threshold signatures and MPC. In 2022, we promised optimistic verification and fraud proofs. In 2023, we promised zero-knowledge light clients and consensus proofs. In 2025, we promise “intents,” “solvers,” and “user experience.”
The bull market is now funding the next iteration of the same dare.
Let’s start with a taxonomy of failure, because the current conversation treats “bridges” as one monolith. They are not. There are at least four architectural families, and each redefines failure in a way that is convenient for its marketing department.
Family one: witness-based custody. Ronin, Harmony, and most early bridges. A set of validators holds keys above a threshold; they watch chain A, witness a lock on chain A, and authorize a mint on chain B. This is not cryptographically beautiful, but it is brutally simple — and it concentrates risk in a human-sized committee. Seven of nine keyholders were compromised during the Axie-Infinity era, and there was no cryptographic trick behind it: it was social engineering across a distributed network of remote, high-value targets. The attack was not a code exploit; it was a weakness in the surface between code and the humans who hold it. The same failure mode governs current institutional “custodian rails” that process institutional flows — the custody is better marketed, not better structured. The security assumption of a witness-based bridge is that the keyholders will not be simultaneously bribed, coerced, or hacked. That is an employment risk, not a cryptographic guarantee. Every bridge that trusts a committee is a bank with extra steps.
Family two: optimistic verification. Nomad and Across represent this family. The innovation is clever: instead of trusting a validator set, any honest observer can raise a fraud proof within a challenge window and freeze the contested state transition. The security assumption is that at least one honest watcher will see the fraud and speak before the window closes. That assumption has three hidden dependencies. First, the watcher needs the ability to post a bond large enough to signal commitment. Second, the watcher needs reliable access to canonical state — which, for a bridge with off-chain relayers, is not always available. Third, the fraud-proof mechanism itself is code, and code has bugs. Nomad’s collapse came from exactly this: the system correctly assumed an honest watcher would exist, but the dispute-resolution mechanism was itself compromised by a copy-paste root that turned the protocol’s own crypto-economic trust into a public free-for-all. The failure was not a breach of the security assumption; it was a bug in the assumption’s own implementation.
Family three: light clients and zero-knowledge proofs. The scientifically honest family. Cosmos IBC, various zkBridge designs, and the current generation of “proof-of-consensus” bridges. These do not ask you to trust a committee; they ask the destination chain to verify the consensus of the source chain directly. In theory, this is as close as we have to a true cryptographic guarantee: if the source chain’s consensus is sound, the bridge’s verification is sound. In practice, generality is the enemy. ZK light clients require proof systems, verification contracts, and message-format translation layers. Every adapter between the bridge and a new chain is a new, unproven surface. One of the crucial failure modes in the zk-bridge space is not in the proving system itself but in the metadata: message formats are often insufficiently canonicalized, replay protection is assembled per handshake, and state-commitment ordering differs across ecosystems. The chain itself may be sound; the translation layer is a patch of engineering decisions, each of which is a field hospital for a future exploit. The proudest architecture in the category still builds its castle on a swamp of small, informal decisions.
Family four: liquidity networks. Hop, Connext, and various atomic-swap designs that move canonical assets rather than minting representations. These avoid the custody problem by never actually creating a bridged derivative. You put USDC on chain A; the network finds a counterparty who wants USDC on chain B; they swap in a way that, economically, squares both books. The security assumption is market-level: unless one side fails to settle, the system is self-correcting. The problem is liveness across chains in a world where one side can go down mid-swap, and the economic utility of cross-chain being concentrated in a few professional market makers who can pre-fund both sides. These networks are the safest because they are the least ambitious — they do not pretend to deliver general message passing; they only pretend to deliver liquidity. And their centralization is not a security flaw. It is a market structure. The observable fact is that industry-wide, the most widely used “bridges” are still the custodial ones, because users optimize for speed and UI, not for architecture.
Now — and this is the part I want you to read carefully — the economic security paradox. Every bridge architecture I just described, without exception, has the same incentive asymmetry: the attacker needs to be right once; the defender needs to be right every time. The cost of attacking a committee-based bridge that secures $2 billion in locked value is not the cost of compromising cryptography; it is the cost of compromising seven people, or five people, or in some cases three. I have read enough leaked internal post-mortem documents to know that these committees are not staffed by adversarial-threat agents; they are staffed by operations personnel who want to go home on Friday. Attackers who have spent years on cryptocurrency infrastructure can, for a low-single-digit-million-dollar budget, socially engineer their way into a keyholder’s machine or someone’s Slack channel, and the return on that investment, if they act within a 90-second window, is orders of magnitude higher than any legitimate computational return.
But let’s go deeper than “people are the weakest link.” There is a structural reason why bridges disproportionately fail at the worst possible time. Bridge volume is cyclical: it rises in bull markets because users chase yield and new chains, and it falls off in bear markets because usage evaporates. Security spending follows revenue, which means the peak in attack incentives — when multi-billion-dollar volumes sit in a bridge waiting for arbitrage — is the trough of relative security investment. The teams are stretched. The canaries are tired. The incentives for robust testing, for long-running adversarial drills, and for paying security researchers at the market rate are weakest exactly when the prize is largest. I saw this pattern repeated in audit allocations during DeFi Summer 2020, and I saw it again in the 2024–25 cycle: protocols that understand they are in a bull market do not increase security budgets; they increase go-to-market budgets. The two are a trade-off in most DAO treasury votes, and the vote almost always goes to growth. That is not a technological problem. It is a governance problem, and it is the real reason the $2.5 billion figure keeps climbing.
Core insight: a bridge is not a cryptographic primitive. It is a governance decision wearing a cryptographic costume.
Let me extend this across the four families. The witness-based bridge is a governance decision that “these seven people are acceptable custodians.” The optimistic bridge is a governance decision that “the watchers will be sufficient to catch fraud within a window.” The zk-light-client bridge is a governance decision that “our translation layer is complete and canonical.” The liquidity network is a governance decision that “professional market makers are aligned enough to keep the market honest.” In every case, the mathematical machinery serves a social pre-commitment. And social pre-commitments are exactly what crypto’s most valuable primitives are designed to eliminate. That is the paradox in its purest form: we are paying billions of dollars to rebuild the trust architecture that we started this industry to get rid of.
Now, the intents movement is supposed to be the answer to this paradox. Let’s spend the next few hundred words on it, because every pitch deck in this bull market contains the word “intent” somewhere, and I want to show you precisely why it does not solve the bridge problem.
An intent protocol works like this: a user declares a desired outcome — “I want to be long ETH on Base, and I hold USDC on Ethereum” — and the protocol creates an auction where “solvers” compete to fulfill that intent. The solver who can provide the best execution price and the fastest settlement wins the order. The system does not need the user to understand the movement of funds; the solver handles the mechanics, which may include using a bridge, an internal liquidity pool, a centralized exchange, or a complicated arbitrage path. The UX is a seamless one-click experience.
The innovation is real. I am a fan of the market-design thinking behind it: auctions for user flow are a genuine improvement over forcing every user to be their own bridge-robot. But the security model has a new failure mode that I think is under-discussed: the solver is the new bridge. The solver is the entity that, by definition, holds short-lived custody or takes on the risk of the user’s funds during the transaction window. The solver is often a professional operator with deep capital, well known in the space, who can commit to filling the user’s intent against their own inventory. The solver market is not, in practice, a competitive market. The most recent data I have seen — and I have been following this closely since my institutional bridge-building work in 2025 — suggests that in many intent-based networks, the top five solver teams process more than eighty percent of the volume. That is not a bug from the user’s perspective, because the user sees a smooth experience. But it is a centralization vector hiding in plain sight.
The deeper issue is that intent protocols do not eliminate the bridge; they hide the bridge. When a solver fills a cross-chain intent, they still need to rebalance inventory across chains. They still need to move funds from Ethereum to Arbitrum, either through a bridge, a relay, or an exchange. The user no longer sees the bridge, but the bridge is still there, and so is the $2.5 billion in accumulated loss history. What the intent protocol has done is to make the systemic risk invisible to the person who experiences it. The UX improves. The security surface does not. If anything, the bridge moves deeper into the network, which means it is harder to observe, harder to oversee, and harder to hold accountable.
I am reminded of my 2020 article “Governance is Politics, Not Code,” which was my reaction to months of auditing Compound’s governance mechanics. I wrote it because I saw the community treating a vote-counting smart contract as if it were the entire governance process, when in fact the real decisions happened in forums, in calls, in the social pressure of whale behavior. The same confusion is happening now with intents: the code is a clean abstraction of order flow, but the true risk sits in the professionalization of solvers, the opacity of their rebalancing, and the structural concentration that will inevitably be exploited at the exact moment that matters — when the market is volatile and the bridge is busy.
Let me also address what I consider the governance dimension of bridge security, because it is the part that most technical post-mortems skip. When a bridge fails, the actual recovery is a social process. It is a human decision about whether to fork a chain to reverse the exploit, whether to socialize the losses, whether to issue a recovery token, whether to honor the insured claims. The Ronin recovery was a process of negotiation among stakeholders with wildly different power positions. The Wormhole response was a parent-company decision, not a community decision. The Nomad recovery was a goodwill campaign that returned a fraction of the funds and left the majority of victims unreconciled.
These are not edge cases. They are the real governance. The question “what happens when the bridge fails” is not a technical question; it is the constitution of the network, and it is unwritten in nearly every protocol I have audited. My 2022 “Values Audit” of my own lending protocol was the first time I forced my team to write down what we would do in a catastrophe, what we would prioritize, and who we would owe. The exercise was painful, but it revealed that our actual behavior would have diverged from our stated values in the first hour of a crisis. I now count that exercise as the most valuable security audit I have ever done — not because it found a code bug, but because it found that our protocol’s governance was not honest about its own failure commitments.
There is a rule I struggle to get teams to accept: what is to be done in the first hour of a failure must be written before the failure, not composed after it. Most protocols have no such document. If they do, it is a short insurance clause or a multisig process that assumes the multisig is still functional. When the chips are down, when funds are draining, when devs are panicking, there is no time for a constitution. There is only time for muscle memory. And the muscle memory of most teams is to minimize legal exposure, which means to minimize communication, which means to maximize the number of stakeholders who discover their loss through an anonymous wallet movement on the explorer. That is not a security failure. It is a dignity failure. True ownership begins where the server ends — and that includes ownership of the story about what happened to user funds.
The most dangerous code is the code we assume works, and the most dangerous governance is the governance we assume exists because a multisig address is listed on a docs page.
The regulatory shadow makes this worse. The Tornado Cash sanctions established something the legal community is still digesting: the writers of code can be held liable for what their code does after deployment, even when they have no ability to stop it. If you build a bridge, and a sanctioned entity routes stolen funds through it, and your build allows that routing, there is a non-trivial legal theory that you are an accessory. This is not hypothetical. I counseled a fork team in 2023 that wanted to redeploy a non-custodial bridge from a clean repository after a predecessor had been blacklisted. The legal reading we arrived at was genuinely unclear. The developers wanted to walk away rather than assume the personal risk. That is the real cost of the regulatory uncertainty: not the prosecutions that actually happen, but the developers who exit, the innovation that gets rerouted toward permissioned projects, and the open-source ethos that gets quietly replaced by a need for a corporate shield.
Now, the contrarian angle. I want to step back and say what I genuinely believe, not what fits a narrative.
The contrarian case is that most of these bridges are not going to be “fixed.” They are going to be made obsolete.
The industry is converging toward a settlement-centric universe. The largest rollups are already moving from “share a security council” to “trust the base layer’s state.” If Ethereum — or one of the major L1s — becomes the canonical settlement layer for a majority of economic activity, then the two-chain problem that bridges solve becomes a one-chain problem. Crossing from Arbitrum to Base, if both post their canonical state roots to the same L1, no longer requires a bridge that holds custody; it requires reading state-root commitments and executing a withdrawal proof. The bridge becomes a relayer, and the trust model collapses to the base layer, which is the single most audited and economically secure state machine in the industry. If that happens — and I believe it is already happening in the background while the marketing focuses on intents — then the entire bridge category as we know it will shrivel into a relatively small set of cross-ecosystem connectors (EVM to non-EVM, L1 to L1) that are rare enough to be worth deep, bespoke security engineering.
The funding is not going there. The funding is going to intents, to chain abstraction, to solver networks, to all the layers that sit on top of the bridge problem and reintroduce the trust surface one level up. We are building a skyscraper on the exact plot of land where the last one collapsed, and the new architectural diagram is, in its essentials, the same diagram with a more expensive label.
My honest recommendation to builders in this bull market is not “build a safer bridge.” My recommendation is to ask why your bridge exists in the first place. If the answer is “because users want to move assets between chains,” then examine whether those chains need to be separate at settlement. If you are building a new L1, the question you should be answering is not “how do I connect to the rest of the ecosystem,” but “what is the durable value of my sovereignty, given that sovereignty is the thing bridges are constantly undermining?”
The industry treats interoperability as an unqualified good. I disagree. Interoperability without a shared source of truth is just another term for a custody arrangement with extra security theater. The crowds who chant that debate is the compiler for better consensus will tell you that we need more cross-chain dialogue, more committees, more governance interoperability. I tell them that a governance process spread across three chains and a dozen committees is not more decentralized; it is more opaque. The debate that matters is the one that happens before the architecture is chosen — the one about what failure means, who absorbs it, and how the story gets told. Every other debate is a post-mortem waiting to be scheduled.
We are in a bull market that is repainting the same risk surfaces with brighter colors. The new names — intents, solvers, chain abstraction — are the same custody dilemmas with better UX. The $2.5 billion figure will not stay at $2.5 billion; it will grow because the prize grows, the security budgets lag, and the regulatory shadow makes it harder for honest engineering to compete with opaque institutional arrangements.
Watch the settlement layer. Watch who holds the emergency pause keys. Watch who profits from the auction, because that is where the risk is moving. And if you are a builder, write your failure constitution before you celebrate your success.
The next cycle will not reward the team with the best cryptography. It will reward the team that could answer the simplest question, asked in the darkest hour: when this fails — not if — whose money is at risk, who decides, and what does the story say?
True ownership begins where the server ends. And in a world of moving servers, ownership is the one asset nobody has figured out how to bridge.