Opinion by: João Garcia, DevReal lead at Cartesi.
Decentralized finance markets itself as a transparent alternative to Wall Street, but in practice it has rebuilt a simplified version of finance optimized for low on-chain computation and minimized gas costs. That engineering trade-off—prioritizing affordability and determinism over continuous, compute-heavy risk processing—limits DeFi’s capacity to handle market stress.
When markets move faster than the virtual machine
DeFi replicated exchanges, lending, derivatives and stablecoins, but these systems are tightly constrained by their execution environments. Risk parameters are often static; collateral thresholds adjust slowly through governance, not automatic recalibration. Liquidations use fixed formulas instead of adaptive portfolio models that account for changing volatility and correlations. These choices frequently reflect computational constraints: public blockchains lack native floating-point support, iterative simulations are expensive, and recomputing cross-asset exposure on-chain is often impractical. As a result, financial logic is compressed into deterministic, gas-efficient forms that lose nuance.
That design holds up in calm markets, but volatility reveals the limits. During MakerDAO’s “Black Thursday” in March 2020, vaults were liquidated with effectively zero bids as auctions faltered under collapsing prices and congestion. Later, Aave and Compound saw mass liquidations triggered by fixed collateral ratios rather than dynamic risk recalculation. When Curve’s pools were destabilized after a 2023 exploit, lending protocols that treated LP tokens as static collateral amplified systemic stress. In these episodes, decentralization wasn’t the primary failure; rather, rigid financial logic ran on execution layers that couldn’t recompute risk as conditions deteriorated.
By contrast, traditional markets evolved around heavy computation: banks and clearinghouses run thousands of stress scenarios, dynamically recalculating exposures and margin requirements as volatility and correlations shift. They rely on substantial computational infrastructure and mature numerical tooling that public blockchains weren’t built to provide.
The illusion of simplicity
Reducing on-chain computational complexity can lower some attack surfaces, but it doesn’t eliminate financial complexity—it pushes it off-chain. When risk can’t be modeled transparently on-chain, it migrates into dashboards, analytics teams, discretionary parameter changes and emergency governance. Settlement may remain decentralized, but the adaptive intelligence that stabilizes the system operates outside deterministic execution. During stress, rapid human coordination, oracle inputs and large token holders gain outsized influence. What appears simple in smart contract code can hide a more complex, less auditable operational reality.
DeFi’s convergence on static ratios and deterministic curves wasn’t because they’re superior, but because richer models were too expensive to run on-chain. As markets deepen and instruments interdepend, that compromise becomes more dangerous: fixed thresholds meant to guard protocols can instead amplify crises.
Computation as a missing primitive
The deeper constraint is execution design. If verifiable execution environments approximate general-purpose systems—offering native floating-point support, iterative algorithms and access to standard numerical libraries—DeFi’s financial design space widens. Protocols could implement scenario-based stress testing on-chain, margining that responds to observed volatility rather than slow governance cycles, and multivariable risk scores instead of binary heuristics.
The goal is not complexity for its own sake, but keeping financial intelligence inside the protocol where it’s visible and enforceable instead of externalized to operational layers users cannot easily audit. These are architectural choices, not inevitable consequences of decentralization.
A credibility ceiling
DeFi faces a structural choice. One path preserves gas-optimized minimalism, keeping on-chain execution simple while pushing sophistication off-chain. That maintains clarity at the contract level but limits how responsibly DeFi can scale. The other treats computation as a first-class primitive, accepting more capable execution environments so systems can adapt, recompute and stress-test transparently. Markets won’t simplify themselves to fit virtual machine constraints; if DeFi aims to operate at meaningful scale, its computational foundations must evolve with its financial ambitions.
Opinion by: João Garcia, DevReal lead at Cartesi.
This opinion article presents the author’s expert view and may not reflect the views of Cointelegraph.com. This content has undergone editorial review to ensure clarity and relevance. Readers should conduct their own research before taking actions related to the company.