DeFi Today

I love Morpho Blue. It’s the most elegant codebase DeFi has produced. That's why I've been shilling Morpho so hard since the launch in 2023, that's also why I’ve spent the past year building @monarchlend - an interface and toolkits that lets users bypass vaults and supply directly to individual Morpho markets.

The reason is simple: I don’t trust curators. Their incentives are misaligned with mine as a depositor, and conceptually, intermediaries are exactly what DeFi set out to eliminate. Recent discussions around xUSD, mHYPER and constant drama with Morpho vault curators makes this clear.

Managed vaults make sense. But it’s wrong that over 90 % of deposits now flow through them. It’s like we built a global, peer-to-peer stock exchange, and 90 % of participants only buy ETFs. Its looks simpler — but it kills the real market mechanism.

Here's why the curator meta is not the future.

Incentives Drift, and Risk Follows

The Principle Agent Problem:

The person acting on your behalf doesn’t necessarily act in your best interest.

Curators earn fees on deposits, not on performance. A 5 % APY on $100 M pays better than 15% on $10 M. Their business objective is to scale, not to maximized risk-adjusted return for each dollar.

Wismerhill

@0xWismerhill

Yield farming changed a lot this year. We went from trying to find alpha in exotic chains, new underfarmed protocols, illiquidity premiums, and outperforming loops to gated private deals and incestuous cronyism. Recent examples, such as Stable's pre-deposit vault and rising

211

7:24 AM • Oct 29, 2025

TVL can also become a marketing metric for “safety,” and safety attracts even more TVL. Smaller vaults chase yield to compete—often through reward farming or side deals. The xUSD drama this week — where curators trusted a 4× leveraged “stablecoin”—shows how easily “managed” risk becomes un-managed exposure. Aa @definikola pointed out, the risk curators today "chases marginal APY boosts to increase your TVL at a cost of listing risky/self-backed collateral"

definikola

@definikola

I will say it again.

Today's curation models put more attention to asset management and not enough (to say the least) attention to *risk* management.

Outcome is going down the risk curve far enough so we have 70% of all CT drama in the last year or so related to shady curation

87

6:00 PM • Oct 29, 2025

This isn’t about bad actors. It’s structure. When managers take risk with other people’s capital, upside is private and downside is socialized. That’s moral hazard, the quiet engine behind every over-levered blow-up in 2008. Heads, they win; tails, depositors lose.

And because curation is rewarded by size, not prudence, we now see what summarized perfectly: “Yield farming has turned into gated deals and incestuous cronyism… curators-tokenized yield funds favor the protocols that give them TVL.”

Again, curators are simply playing a different game. Their KPIs are growth and visibility, not depositor risk-adjusted returns.

Maps, Territories, and the Illusion of Safety

I recently learned a new concept: The Map-Territory Relation: Polish-American philosopher Alfred Korzybski said, “The map is not the territory.” -- the abstraction is not the reality.

In DeFi, curators draw maps—risk frameworks, collateral tiers, safety scores. Over time, those maps become the reality everyone references.

New vaults use existing allocations as validation: “if other curators listed it, it must be safe.” Projects learn to optimize for the map—appearing Tier A instead of being sound. Soon, vaults are referencing vaults, and the ecosystem starts orbiting its own abstractions. This is why "modeling risk" can never be perfect, the more we model risks, the less we measure it.

That’s not risk management; that’s meta-risk creation. The moment everyone prices safety by proxy, information decays. Some markets never get funded because they’re too small to fit a curator’s "model", while others get over-allocated because one vault made a convenient assumption.

Curators manage uncertainty for many, but with less information than any single user has about their own preferences. They’re forced to generalize—to guess a “median” risk appetite that doesn’t exist.

It’s like drawing a world map without ever visiting the countries, and then telling the locals to navigate by it. In reality, the locals—the actual market participants—often know the terrain far better. DeFi enables (and should encourages) everyone to draw their own paths, not just follow someone else’s abstraction.

The Way Out

Vaults are useful. They batch transactions, simplify UX for beginners, and is extremely helpful when it comes to onboarding tradfi. But they should not be the default for users who ask for "DeFi".

Going back to the ETF metaphor: we built a decentralized trading network, then told everyone not to trade. We tell users to buy the index—to trust the fund manager.

Direct allocation isn’t harder. When you supply to a lending market, you only ask: Do I trust this collateral and this oracle? Is this APY worth it?

YAM 🌱

@yieldsandmore

Not everyone knows this, but you can lend directly to individual Morpho markets through @monarchlend, a third-party Morpho interface. This is useful for a few reasons:

- Depositing into a single market lets you earn the APY of just that market. Useful when the borrow rates are

72

6:24 AM • Oct 30, 2025

Managing your own assets is fundamentally different from managing funds for others. You don’t need a curator’s toolkit or models to average everyone’s preferences — you only need clarity on your own.When you participate directly, the road ahead is often clearer than the map drawn for you.

That’s why I've been working on Monarch for so long, and also why I'm launching Monarch Autovaults soon — tools that let you define your own boundaries: total collateral exposure, per-market caps (the Morpho Vault V2 enables this btw), and customizable settings like whether to prioritize yield or availabillity.

It’s the exact same vault infrastructure all curators use, but you own the map.

The more people supply directly, the healthier the market becomes. Each decision adds signal; each deposit restores discovery. Vaults will remain part of the stack, but they shouldn’t define it.

DeFi was never about finding better managers. It was about removing the need for them.

We built a decentralized market. Let’s stop buying the ETFs.

Why boring and inefficient protocols are underrated and Ethereum-aligned.

Special thanks to Danger, Simon, Indigoand Chih Chen Liang for feedback and review.

Vitalik recently published an article titled Low-Risk DeFi Can Be for Ethereum What Search Was for Google. It's encouraging to see him acknowledging the "DeFi teams" who have focused on building this space for years.

While I agree with Vitalik's vision, I believe we can strengthen the framework by focusing on trustlessness as the key indicator of genuine low-risk DeFi. If history tells us anything, it won't be long before every team starts branding themselves as "low-risk DeFi" just to ride the narrative.

I'll argue in this post that trustless protocols are naturally low-risk (and low-yield), regardless of product type, and that pursuing trustlessness provides a more objective measure than classifying by use cases. We won't sacrifice anything meaningful in the end, and these protocols have huge long-term potential for the ecosystem.

Here are the key points I'll explore:

1. The Standard for Trustless Design

2. Why Trustless DeFi is Inherently Ethereum-Aligned

3. Why Trustless DeFi Equals Low Risk DeFi

4. Why should protocols be Trustless

1. The Standard for Trustless Design

In my opinion, a truly trustless DeFi protocol could be defined easily with just one rule: no privileged roles within the protocol. No admin, pauser, executor, rebalancer, or any other special access.[1] This also means protocols should be immutable - no upgrades that could change how my assets are managed.[2]

It should exemplify a hyperstructure, as Jacob describes it. While there may be a "fee switch" to create value for the team and token holders, there should be no privileged players who can manipulate the rules, and it should be fair to all participants.

This doesn't mean every DeFi interaction must meet these standards. But I believe the core infrastructure should, because that's what enables everything else to build on top safely.

2. Why Trustless DeFi is Inherently Ethereum-Aligned

You might be wondering why a protocol needs to be "trustless". Why does it matter?

The reason is that by creating a trustless protocol for straightforward agreements between parties, we are fundamentally changing finance.

Before blockchain, storing value without trust meant hiding cash under your mattress. But idle cash loses to inflation and misses growth opportunities. Any financial agreement - deposits, trades, contracts - required trusting a third party to manage it.

DeFi changes this. For the first time, terms like 'trade', 'finance' and 'contract' don't require a trusted middleman taking fees and adding attacking surface.

This is why I see trustless protocols as the true hallmark of DeFi. They're what make the space special, and they also happen to overlap closely with what Vitalik calls "low-risk DeFi."

This innovation aligns uniquely with Ethereum. Ethereum embodies trustlessness, featuring no centralized control over its protocol and a commitment to credible neutrality. Trustless DeFi protocols reflect these same principles, serving as neutral bases for various financial products. Through Ethereum, we can establish censorship-resistant solutions that allow anyone to finance their portfolio without relying on trust assumptions.

3. Why Trustless DeFi Equals Low Risk DeFi

When Vitalik talks about "low-risk DeFi," it's easy to start categorizing by application: lending = safer, derivatives = riskier. But in my view, the better way to identify low-risk protocols is by how trustless they are. The most trustless protocols are naturally low-risk, because they accept inefficiency in exchange for resilience.

Inefficiency Shows Up Everywhere

Ethereum's execution environment creates natural inefficiency. With 12-second block times and MEV, even simple trades become inefficient. A DEX order might fail due to front-running or network congestion, forcing users to accept wider slippage buffers just to execute reliably.

But the more important inefficiency (and the best lens for understanding protocol risk) is capital efficiency.

Capital Efficiency

Capital efficiency is about how effectively a protocol uses idle assets. This is where you see the clearest trade-off between safety and yield. The same underlying function—lending, trading, derivatives—can have vastly different risk profiles depending on how efficiently the protocol uses capital.

Lending Protocols

Lending protocols essentially choose between two design philosophies: isolated lending markets vs monolithic markets. Morpho has become the gold standard for the isolated approach.

In Morpho's design, borrowers lock collateral in the contract, and it just sits there until repayment. That collateral doesn't generate extra yield—it's only there to back the loan. The benefit is clear: liquidations always work, and lenders' risk profiles stay static and predictable.

By contrast, most lending protocols allows rehypothecation in a monolithic market setting, lending out collateral for extra interest. This increases capital efficiency, but now collateral might not always be available, and lenders must trust additional assets to back their loans. What started as a "low risk" lending scenario suddenly carries compounded risks.

Options Protocols

Option protocols show the same dynamic. Our first impression of options is usually about efficiency and extremely "high-risk, high-reward". But this is not always true.

Here's how a less efficient implementation (Pods Finance first pioneered this kind of physically-settled option in 2019[3]): to sell one call option on ETH, you lock the full ETH upfront. Want to sell an ETH call for a $50 premium? Lock 1 ETH which is worth $4000+ today.

It's extremely inefficient, but it's bulletproof because it has zero trust dependencies: the buyer himself can choose when to exercise this right, and fill the trade against the locked asset. This is even more trustless than CDP stablecoins and all lending protocols, which all have orale dependencies.

P.S., To this day I still believe this would have been the best venue for Ethereum Foundation to earn yield on their treasury ETH. 💰💰

The Pattern

The pattern is clear: trustless protocols lock up more assets and make conservative assumptions. More "efficient" protocols add dependencies—oracles, managers, complex risk models. Each dependency boosts yield but adds failure points. And risks stack quickly.

This is why I don't think "low-risk DeFi" should be defined by application type, but by design philosophy:

Low-risk DeFi isn’t about the application type. It’s about simple contracts with minimal dependencies and low trust assumptions. They yield less, but they survive longer.

Stupid and Boring Protocols

Another big shared property between Morpho and Pods is their simplicity. You can learn both contracts in under 30 minutes. They’re simple and intentionally straightforward . Even I could understand Pods when I first read about it in 2020 with no financial knowledge and very limited solidity skills (see Morpho and Pods's code here).

This doesn't imply we shouldn't promote new features for greater efficiency and usability; I just simply believe that "inefficiency" is almost always underrated.

As my friend Mihai put it, Make DeFi boring again. It turns out that the simplicity or "boring" nature of contracts can be a reliable indicator of lower risk.

https://x.com/mihai673/status/1969875847021474259

4. Why Should Protocols be Trustless

Why should protocols move away from chasing “efficiency” and focus on products that may seem “inefficient”? Honestly, it’s not an easy sell. Most teams are driven by PMF and revenue pressure, so they chase higher yields, more features, and VC attention. This feedback loop favors “efficient” designs, while protocols built on trustlessness, self-custody, and financial freedom often get overlooked.

That’s why Morpho’s growth over the past two years has been so inspiring (to me). With minimal trust assumptions, their “boring infrastructure” has become incredibly valuable because it plugs into almost everything—restaking, RWAs, stablecoins. Their success proves that inefficiency is a feature, not a bug. Hopefully it’s not just “cool,” but also proof that boring, trustless design is what creates something groundbreaking long term.

When I think about the "trustless" protocols, I now imagine a graph in my head that shows two very different trust schemes.

The Old Stack of Trust

In the “old” DeFi trust scheme, each layer adds its own assumptions. Risk piles up and often the "DeFi Protocol" itself becomes the single point where all those assumptions converge. This leaves less room for 'trust' to be used.

The New Stack of Trust

In a landscape of more trustless protocols, the base layer stays minimal and predictable. The “green area” above is where optional trust assumptions can be added— gated tokens, curators, governance, oracles, centralized wrappers—depending on what users want. The key difference: these choices happen at the edges, not at the core.

This doesn't mean these trustless protocols can never add trust assumptions. It's quite the opposite: the base layer leaves room for flexibility. Like Uniswap, which is permissionless at its core but still allows both highly centralized and highly decentralized tokens to be traded on top. Often, centralized actors end up choosing permissionless rails, because nothing in the stack blocks them.

Summary: Make DeFi Cypherpunk again

It's not enough to think of "low-risk DeFi" as just a vague category. What would really move the ecosystem forward is stronger recognition—from EF leaders to DeFi builders—of the value in supporting real trustless, inefficient, and boring protocols.

As someone who genuinely enjoys low-risk, low-yield protocols, I'm excited not just by how trustlessness is reshaping finance, but by how it's returning us to the cypherpunk roots. The real breakthrough isn't higher yields, it's eliminating trusted intermediaries entirely. And that breakthrough can only happen on Ethereum, where the base layer itself embodies these same trustless principles.

In Summary:

• Trustless design is what DeFi should be building toward

• Trustlessness—boringness, inefficiency—is a good proxy for low risk DeFi protocol.

Let's make DeFi Cypherpunk again. Trustless Finance, Powered by Ethereum.

Notes:

• [1] The only role that might be somewhat negotiable is the pauser role. If an address can only temporarily halt a protocol, I believe it can still fit within a fair framework and does not undermine the overall accessibility of the system (and the ability to objectively "define" accessibility of the system).

• [2] Having no privileged roles also means that protocols should not be upgradable. An upgradable protocol inherently involves some level of access control, which contradicts with "no priviledged roles".

• [3] In this "American, Physical settled" option model, the issuer locks the full value in the contract, mints a token, and the buyer can exercise the token, and execute the "trade" at the strike price anytime before expiry. This design doesn't require any oracle dependency.

The Agent Identity Crisis

The journey toward true AI agents has been fascinating to watch unfold. Like many others, I've experimented with building various AI-powered tools since the early days of GPT - from language tutors to workout planners and productivity shortcuts. We've called many of these creations "agents," myself included.

But as I've explored more about agent frameworks and their capabilities, I've begun to see a distinction between what we've built so far and what's truly possible. The real potential for AI agents lies not in following commands, but in autonomous decision-making.

And nowhere does this potential shine brighter than in DeFi. While most frameworks have naturally gravitated toward Web2 productivity use cases, DeFi presents a unique opportunity. Managing assets across DeFi protocols generates a constant stream of information that even the most dedicated human can't efficiently process. This is where I believe truly autonomous agents could transform our relationship with DeFi protocols.

Defining True Agents

There are actually competing definitions in the industry. Anthropic defines agents as "systems where LLMs dynamically direct their own processes and tool usage, maintaining control over how they accomplish tasks." This is also how LangChain - currently the biggest agent development framework - defines them.

OpenAI, however, describes "agents" as level 3 of their "5 levels of AI development strategy to AGI," a stage we haven't reached yet. The key distinction in OpenAI's definition is that true agents must have the ability to act autonomously over extended periods.

I find OpenAI's definition more compelling. The ability to initiate actions without human prompting is what separates a truly helpful agent from a sophisticated but ultimately reactive tool. This autonomy is the critical breakthrough we're working toward.

P.S. There are different interpretations of the boundaries between AI levels in OpenAI's proposed framework. I found this post a very easy digest that I’d recommend others to read as well!

The Current State of AI (Feb 2025)

Today, AI development primarily focuses on enhancing LLMs by adding tools to "smart frameworks" - systems that allow LLMs to access external tools.

MCP (Model Control Protocol) is a powerful example of this approach - an open standard that leverages the power of the open source community, to let anyone build and plug specialized tools into LLMs. With frameworks like MCP, you can install web search functionality alongside "chain of thought" reasoning, effectively turning your desktop Claude (an LLM client that supports MCP) into a powerful research assistant. These frameworks allow for integration of specialized knowledge bases, use of other softwares, and other extensions to supercharge any LLM client.

While impressive, these systems remain fundamentally reactive. The LLM still needs to be triggered by a human, then it selects from its “toolbox” to generate outcomes. They're more capable assistants, but still just sophisticated responders waiting for human prompts.

The Missing Piece to True Autonomy

The key here, compared to what the OpenAI framework suggested, is that we don't have agents "working on their own" - most still passively need our commands, or need “human in the loop” at best.

Our goal is to build fully autonomous agents: ones that can observe and do not rely on commands. That would really be the breakthrough. So how do we build truly autonomous agents instead of passive chatbots?

If you really think about it, the basics might not be that different. Fully autonomous systems (like the human mind) are also somewhat reactive systems, but with way more triggers. Our actions are prompted by things like hunger, mood, weather, or social cues. We have sensors all over our bodies constantly taking in information, making us respond without having to think about it. Building truly autonomous AI needs the same thing - a network of "triggers" that start actions based on what's happening, not just direct commands. We're not trying to build AI that acts randomly, but AI that knows when to act based on the right signals.

Building the Trigger Infrastructure

Imagine if we could give AI all the "triggers" we need: alerts when it's time to work, notifications when something important happens, updates when news breaks, or even subtle cues when something interesting occurs. With these triggers in place, we could use LLMs to process this information and reason - creating decision-making patterns remarkably similar to human behavior.

This is ambitious but achievable. While continuously monitoring everything seems less practical today due to cost constraints, we can build toward it systematically. MCP gives us an open interface for tool usage - what I see coming next is a similar open-source interface for triggers. Imagine a protocol where users can plug in their own "triggers" just like they select their own tools today. Users could customize which signals matter to them: some might want agents that respond to market volatility, others to social media trends.

Why DeFi is the Perfect Testing Ground

So what does this have to do with DeFi? DeFi represents the ideal environment for autonomous AI because of its transparent, permissionless nature. With DeFi, agents can directly verify everything - from reading smart contract code and checking audit reports to analyzing on-chain data. This allows them to genuinely understand how protocols work, assess risks independently, and make informed recommendations without relying on trusted third parties.

This verification capability simply isn't possible with tradfi or closed-source apps where programs are executed inside a black box. In those systems, AI would still need to trust the lots of parties involved.

Today's DeFi "agents" mostly function as sophisticated chatbots - they're good at understanding user intent and helping execute transactions, but they still wait for commands. The missing piece is that trigger layer to transform them into truly autonomous financial assistants.

The New Kingmakers: Signal Providers

My theory is that whoever controls quality information sources and provides them as API infrastructure will capture significant value in this new paradigm. Imagine having all these different signals available - from real-time sentiment analysis on CT to on-chain vulnerability alerts - all accessible through a common interface.

The key is making this an open, customizable standard similar to MCP. The most reliable news sources (likely Messari in crypto today) would be connected to dozens of different agents, each built for different purposes. Users could select which triggers matter to them, creating truly personalized autonomous agents that reflect their priorities and risk tolerance.

The Monarch Vault: First Steps Toward Autonomy

With the launch of Monarch Vault, we mark the beginning of our vision for truly autonomous agents in DeFi. This is our first experiment in creating systems that can make financial decisions with minimal human intervention.

What to Expect From Monarch Vault

Monarch Vault is a Morpho vault where an AI agent serves as the allocator managing user funds. Important to note: the allocator has specific limitations - it cannot move assets out of the markets or add new markets. It can only reallocate assets between a pre-approved set of markets with caps. This creates a safety boundary while still allowing the agent to make decisions.

Why Morpho? It offers minimalist contracts that deliver lending functionality with zero dependencies, plus the highest security standards in the industry. No entity—not even the Morpho DAO itself—can interfere with markets created on Morpho. This level of immutability is essential for minimizing risks.

The current agent (what we call the M1 agent) analyzes on-chain liquidity events (Deposit, Withdraw Borrow, Repay) and makes lending allocation decisions to optimize returns without requiring constant oversight.

We designed the UI with full transparency in mind - helping both ourselves and all depositors understand exactly how the agent operates. Every decision and the reasoning behind the LLM is visible and accessible to everyone. No black boxes here. All moves are transparent and explainable, so you can clearly understand what's happening with your assets and why each decision was made.

The Multi-Agent Future

We're already working on the next iteration: a multi-agent system resembling an "office" where different specialized agents analyze various aspects of the market before coming together to make group decisions. One agent might focus on risk assessment, another on yield opportunities, and a third on macro or market volatility - each responding to different trigger sets but collaborating on final decisions. Stay tuned, it’s coming soon!

Beyond Vaults: The Vision for Fully Aligned Agents

While Monarch Vault represents our first step, my personal “endgame” for DeFi agents extends far beyond. Vaults still carry trust assumptions and don't fully solve centralization issues due to the extra layer of "roles" they introduce. What I'm ultimately building toward is something more fundamental: a personal financial agent that truly understands my risk appetite and goals, operates without intermediaries, and maintains perfect incentive alignment with me.

The vault is just the beginning - an open experiment to test whether AI agents can effectively manage lending positions. But the destination is clear: fully autonomous, personalized financial agents that act as extensions of ourselves, filtering the noise of markets through the lens of our individual goals and preferences.

This isn't just about better yields or easier DeFi - it's about reimagining our relationship with financial systems through truly aligned, autonomous AI. The future of DeFi isn't just decentralized - it's personalized and accessible to everyone.

Both Morpho and Euler have been getting a lot of attention lately, and I'm genuinely impressed by both protocols. They're built by top-tier DeFi teams who've created lending protocols as completely decentralized hyperstructures.

Also, for the first time in my 4-year DeFi journey, I actually feel very confident recommending protocols to friends and teams. Both Morpho and Euler set the bar for security standards in the industry, and they're built with that true decentralized ethos we've all been waiting for.

Since I started diving deep into these protocols (and building on top of one), I've had countless conversations about them. The topic was especially hot at Devcon, the two names come up very constantly from protocol integration to everyday use. These conversations helped me develop a mental model for understanding both protocols more deeply, and I think it's worth sharing what I've learned.

In this article, I'll focus on comparing their high-level features and different approaches. We won't get into the nitty-gritty of implementation details or "coding style" - though those are fascinating topics that deserve their own discussion another day.

Disclosure: I hold both $EUL and $MORPHO tokens, and I'm currently building Monarch Lend, a customizable lending platform on top of Morpho. While I serve as a delegate for MorphoDAO, I receive no compensation or direct incentives from either team. Please keep these connections in mind as you read through my arguments.

Monolithic Lending vs Isolated Lending

Before diving into the actual comparison, let me (re)define the two types of markets a bit more:

Monolithic Lending Market: Multi-Collateral + Mutual Trusted Cluster

First, I want to define “monolithic”.

Monolithic Lending Protocols typically refer to protocols that create one large, unified lending market where "the protocol" is essentially the market itself - like Aave's aUSDC, Compound, or Euler V1. In these markets, assets can be cross-margined, borrowed, and generate yield.

This naturally forms a "mutually trusted cluster" of assets, where each asset shares risk with others in the cluster.

In this post, I use "monolithic" to describe markets: If a market resembles an Aave V3 market, I call it a "monolithic lending market". These markets typically have two key properties:

1. Enable multiple collateral types to be used together for borrowing

2. Collateral could be borrowed out and generates yield if configured

While EulerV2 functions as a factory for launching various lending markets (from complex monolithic to isolated), its architecture optimizes for monolithic lending markets where assets interconnect and supply reuse is encouraged.

So while EulerV2 can support multiple variations, this discussion focuses on its role in launching monolithic markets. I'll use "monolithic markets" to describe Euler's flexible markets, while being clear that EulerV2 itself is not a Monolithic Lending Protocol.

Isolated Lending: Powered by Simple Loan / Collateral Pairs

Morpho, in contrast, is a protocol designed to create fully isolated markets. Each market is defined by a single loan-to-collateral asset pair, strictly maintaining this one-to-one relationship.

When creating a more "dynamic lending marketplace," Morpho relies on intermediate contracts called vaults to allocate funds across different underlying markets. You can envision this as liquidity being distributed across various isolated pools, where borrowers with different collateral or oracle preferences need to go to different pools (markets).

Now that we've set the context, let's dive deeper into understanding the fundamental differences between these approaches. Let me repeat the basic ideas:

• EulerV2 is a protocol to create almost any flexible lending structures, but primarily focus on monolithic markets. When I mention monolithic markets, you can assume I’m also talking about EulerV2

• Morpho is a protocol designed to create isolated lending markets and other structures to connect them. When I mention isolated lending protocol, you can assume I’m also talking about Morpho.

Borrowing UX

The borrower experience on Euler is generally more convenient, primarily due to its flexibility in allowing multiple collaterals to be used simultaneously. While Morpho's design requires borrowers to maintain separate positions to borrow against different assets (such as one position for ETH-USDC and another for BTC-USDC), Euler consolidates these into a single position.

Consider a scenario with a large delta-neutral portfolio: in a perfect monolithic market, you could borrow substantial amounts of stablecoins with no liquidation risk. However, in isolated markets, you'd need to manage several positions and monitor liquidation risks across all of them. Even if you have automation liquidation protection tools, the amount you could borrow is still not going to be comparable to monolithic markets.

Borrow Rate Comparison

An interesting consideration regarding borrowing rates is that the isolated approach should theoretically lead to more equitable market rates for each position. For example, borrowing USDC against ETH might carry a 5% rate, while borrowing USDC against LRT might be set at 15%. These rates remain distinct and position-specific. As a borrower with single asset collateral, you pay exactly how your collateral is being priced.

In Euler's cluster, markets typically include multiple collateral types (often exceeding 10 different assets), which naturally result in a mixed rate. This might disadvantage users who prefer borrowing against "safer" assets. And intuitively, it benefits those borrowing against riskier assets, like memecoins if it’s ever allowed, as the risk is partially distributed across the safer collateral within the same pool.

So, it would theoretically be cheaper for borrowers with low risk assets to borrow on Morpho. But as it is today, it's hard to observe the rate dynamics in practice, as both protocols are influenced by lots more by other factors that affect rate pricing like reward programs.

Trust Assumptions

Another consideration is the trust assumption. In monolithic markets, a "governor" entity typically holds rights to update market configurations for managing overall risk. Borrowers must trust these governors won't make drastic changes against their interests, such as lowering the LLTV of their collateral which could trigger liquidations.

Euler V2 addresses this through their LTV Ramping mechanism, which provides significant protection for borrowers against sudden changes.

In contrast, Morpho's underlying markets are immutable and have no concept of "ownership." Borrowers maintain full control over their positions. This gives borrowers in isolated lending pools more autonomy over factors affecting their positions.

Capital Efficiency and Rehypothecation

This is a relatively easy one, collateral rehypothecation is one clear advantage of Euler and its monolithic markets, allowing borrowers to earn interest while simultaneously providing liquidity to another lending market.

In Morpho's design, collateral deposited into markets cannot be borrowed out. This is less efficient but prevents some annoying issues, such as borrowers being unable to withdraw their collateral. People can theoretically loop things and borrow with the “yield bearing collateral”, but that’d be another market that you have to source liquidity first.

A simple way to understand the efficiency difference is through a "mutual lending" scenario: Imagine Alice has ETH and wants to borrow DAI, while Bob has DAI and wants to borrow ETH. In Euler's monolithic market, they can efficiently borrow using each other's collateral directly. However, in Morpho's isolated markets, each person would need to find separate suppliers for their loans. This illustrates how monolithic markets can create natural synergies between borrowers and lenders with complementary needs.

Do(n’t) Trust the TVL

An interesting implication of this appears in the TVL: with Morpho, TVL typically correlates directly with protocol growth - as more people borrow or lend, the TVL consistently increases. In contrast, with Euler V2, it's possible for TVL to decline even as “protocol usage” grows, for example if many passive lenders become active borrowers, they would just start taking money out of the protocol with their existing supplies as collateral.

P.S. Euler V2 can theoretically accommodate both approaches through its escrow vaults (where collateral can't be borrowed) and normal borrowable vaults. But in clusters that offer both options, liquidity would go toward borrowable vaults. This makes practical sense: since borrowers are already exposed to shared market risk when they borrow, they're all incentivized to earn additional yield on their collateral.

Liquidity Aggregation / Fragmentation

Here comes my favorite comparison part: liquidity. This is literally the question everybody asks: "Which protocol will have better liquidity?"

It's a good question, but not a great way to ask it. It's too vague, and any answer could make sense. That's why I believe we should focus on these two questions instead:

1. "Where does liquidity get aggregated or divided?"

2. "Where are the network effects?"

Monolithic Markets:

Liquidity aggregates everywhere within clusters

In monolithic systems, liquidity concentration happens within single clusters, naturally leading to having a primary cluster - just like how DeFi lending was heavily concentrated in Compound's cUSDC, Aave's aUSDC, and Euler V1 before 2023.

All liquidity within a cluster is essentially "shared" - onboarding a new asset (either as collateral or having a market) into the cluster is relatively easy, and users can enjoy an expanding selection of collateral assets.

Where is the Network Effect -- Primary Markets and Tokenization

The network effect primarily manifests at the tokenized vault level (market level) - a successful USDC vault aggregates substantial lender and borrower activity, creating a centralized hub for USDC liquidity.

All suppliers and borrowers can come to a big connected market. Very intuitively, this aggregates lots of different sources of liquidity, and let all users share the same fungible token for the supplied asset.

These tokenized assets often gain broader acceptance and can be utilized in various ways, such as Curve's spot markets or derivative markets like Hyperdrive or Pendle, or even function as interest-bearing stablecoins. I believe this effect would be even more amplified in DeFi, as ERC20 integration is very well-explored and people are very familiar with integration based on this interface.

IMO this is one of the biggest advantages of monolithic markets: once you reach a certain scale and everyone considers it "big enough," it's not just a tokenized supply position anymore - it's actual money that even "protocols" could hold.

Liquidity fragment between clusters

Euler V2 can be used to launch completely separate monolithic markets, but launching a new cluster means starting everything from scratch. One great feature of Euler V2 is that it's very easy to "connect collateral vaults" from other clusters, allowing users with supply positions to come to your cluster and borrow. However, this means inheriting the risk of the original market, and it only solves part of the problem on the borrowing side - you still have to start from zero to find suppliers.

You can see this on Euler Explorer too: currently, the biggest cluster outside of "Euler Prime" is the Stablecoin Maxi by Re7. Looking at the details, it's practically just operating as a single USDC-sUSDe market, not really gaining traction as a "monolithic cluster."

We're still way too early to judge Euler V2's growth, but this is likely the biggest obstacle going forward for Euler to truly expand its vision of being the protocol that serve as a framework to connect “multiple monolithic markets”.

Isolated Lending

Liquidity fragment between borrowable markets

Morpho-style protocols operate differently - top-layer vault contracts only function as aggregators, so liquidity isn't truly "pooled" together from a single supply flow's perspective; instead, it's divided into different markets. The actual "supply and borrow" activities happen in these base markets, making it more challenging for intermediate vaults to achieve strong network effects where everyone naturally gravitates to one place for liquidity. Instead, vaults must continuously compete with each other based on yield and risk profiles.

This doesn't mean it's impossible to develop a vault big enough to become a "popular ERC20" - it's just a lot harder to reach that scale. However, once achieved, a vault can tap into the “ERC20 lego ecosystem” we discussed, and what's cool about Morpho is that when one vault succeeds, it helps pull others up with it.

Liquidity aggregates from different sources into “markets”

All vaults share the same underlying “markets”, so any vault growth can indirectly help others as well, as there will be more liquidity into the base layer, we can expect more borrowers to come because of the liquidity, and all vaults benefit from using some of the shared markets.

One key advantage that I think we’re starting to see now, is that it’s relatively easy to launch a new vault without worrying about the starting liquidity. When you first start a vault, you’re not trying to create a new market so to speak, you’re just trying to create a good strategy for people to distribute their supplies. You already have other lenders and borrowers in those pools, so you don’t have to worry about the cold start problem.

Network Effect could happen across use cases

Consider two suppliers: one wants a very low-risk 3% yield, while another seeks the most degen strategy with the highest possible returns. Usually, these suppliers would never combine their liquidity, but in Morpho, some of their funds might end up "pooled" together, perhaps in one of the semi-risk markets.

The unique network effect here emerges when different "groups" can mix together. This means the Morpho ecosystem can more easily expand to fit literally everyone's risk appetite without starting liquidity from scratch for each use case. If you check out the markets page of Monarch (yes, the platform I built), you'll see many more adventurous markets being created.

TradFi Integrations

Let's briefly talk about how both protocols can accommodate TradFi or institutional liquidity while addressing compliance concerns.

Euler's “Controller vault based” architecture makes it straightforward to create whitelist-only markets where only approved actors can supply or borrow. This is particularly useful for institutional participants who need to operate within regulatory frameworks, you can govern all borrowers and suppliers easily by adding hooks to each markets in the trusted cluster.

Morpho can supports "permissioned markets" through a different approach - by wrapping tokens into permissioned ERC20s. For example, one market achieves this on Base by wrapping USDC into verUSDC, ensuring only KYC'd users can borrow.

The strength of Euler's approach lies in its ability to efficiently create compliant clusters for multiple assets. While Morpho's approach is more indirect, but it also demonstrates how a minimum primitive can be adapted to build any type of market structure.

Underlying Hypothesis

I want to also mention how the architectural choices reflect different fundamental assumptions about DeFi lending. What we talked about in the previous sections kind of implied this already, the two teams are solving “DeFi lending” differently because they saw different bottlenecks in scaling, and therefore invented different systems to address it. But here I want to zoom out even more and try to think about the underlying ethos and hypothesis of each protocol.

Monolithic Lending: Compete as Alliances and Scale with Higher Efficiency

The monolithic approach prioritizes concentrated liquidity, based on the assumption that combining borrowers and suppliers with different collateral preferences and risk tolerances creates net benefits. This architecture believes that as more assets join a mutually-trusted cluster, they bring multiple groups together and scale as one entity. As mentioned earlier, this could become particularly powerful in the ERC20 DeFi lego ecosystem if we experience another DeFi renaissance.

Also, monolithic lending focus on capital efficiency. This resonates with how Euler V2 constructed their vault-based architecture to encourage reuse of vaults – supplies could be used as collateral easily in many different new markets. With more utilities provided to suppliers, the lower the opportunity cost and hence increased supply-side liquidity.

An unavoidable challenge with this approach is governance and management at scale. While Euler V2, as a framework for launching multiple monolithic markets, could potentially "sidestep" this bottleneck by enabling different clusters, the system still requires more trust at various levels - for instance, market terms being governable affects everyone in the cluster.

Though Euler V2's framework is sufficiently decentralized that users don't need to trust governors to act benevolently (it's built so that even malicious governors can't cause catastrophic damage), the core tradeoff remains clear: the markets created by Euler likely favor efficiency and concentrated liquidity at the cost of introducing (external) governance.

Isolated lending: Connect Liquidity Sources with zero Trust Assumption

Isolated lending, by contrast, embraces the philosophy that mixed markets have inherent limitations—no single market can satisfy all users, and what's essential is a shared, ungoverned base layer that all activities can share. This underlying "isolated" property enables people to build whatever they want without requiring trust.

Here's what I see as the hidden hypothesis: Morpho represents the only path to bringing more "truly decentralized liquidity" into the existing DeFi lending landscape, as it eliminates the need for bureaucracy and governance politics that often stands in the way. There might be many undiscovered DeFi lending use cases that most lending markets overlook, but which become possible within the Morpho ecosystem.

A great example is "protocol-owned" supplies and interest. I recall a discussion at Lyra (now Derive) about whether we should "just accept Aave’s aUSDC instead of USDC" for all deposits into our rollup. The pros included up to millions in annual revenue from interest; the cons were that the company's fate would depend entirely on another protocol. Everyone wanted the yield, but the lack of control was impossible to accept when the whole team's future was at stake.

I believe there are many such "lightweight use cases" that could quickly become viable if the risks were manageable, and the liquidity problem is solved by default. Had Morpho been an option back then, we could have easily created a vault to start earning interest while maintaining full control over which markets we supplied to, giving our protocol full control to not waste that idle liquidity.

Coming back to the original point, what I like about this philosophy is its ungoverned approach to DeFi, viewing the loss in capital efficiency as a necessary trade-off for achieving total decentralization within their ecosystem.

My DeFi option journey Déjà Vu

I believe the "philosophy" behind each approach reveals the hidden value behind each team. Writing about this post reminds me of how different teams approached DeFi options back in the day: Some tackled the problem by focusing on "bringing TradFi liquidity onchain," prioritizing capital efficiency and trader experience, while others built simple, fully-decentralized, physically-settled options with no oracle, hoping to teach the world about the power of a single option position rather than merging 32 positions to trade volatility with portfolio margining.

I see the pro-efficiency trader approach as similar to how Euler views problems, while the minimally-governed approach aligns more with how Morpho is built. Though practically speaking, both Morpho and Euler are less constrained in their direction and actual use cases: Morpho still provides a smooth path for institutions to connect liquidity into DeFi, and Euler is flexible enough to cover use cases including "isolated markets." What I really want to highlight here is the key focus in their design choices, which reflects their core vision.

You can see this even more clearly in their codebases: Morpho takes a minimalist approach, focusing on coding the base market and be un-opinionated as possible, while Euler chose a more general and modular approach, potentially supporting a wide range of use cases like launching a synthetic stablecoin.

I recommend studying both protocols extensively to understand their contrasting design philosophies, and I’m sure you will find the beauty in both minimalist approach and a modular framework. From a protocol design perspective, both teams offer valuable lessons in architectural choices and tradeoffs.

Closing

Despite their fundamental differences, these protocols share one crucial similarity at the protocol level: they are both built as totally immutable public goods. This design ensures they will always work for everyone and provides flexibility for building different applications on top, all while maintaining zero trust assumptions. So even with their "key differences," both protocols offer far more potential than limitations.

Their distinct approaches to DeFi lending aren't competing philosophies but rather complementary DeFi lego pieces, each pushing the boundaries of what's possible in DeFi.

The beauty of DeFi is that we don't have to choose between these approaches - they WILL coexist and thrive together, serving different needs in the ecosystem. As I always tell people: in the end, what matters most is that DeFi users win. This is truly what I expect to see in the upcoming DeFi summer ☀️

Thanks @Crotts__, @MerlinEgalite, @JackChai0922 for review and feedback!