Shortcuts To Scale: How Enso Seeks To Reshape dApp Development

Introduction

The clock is ticking on crypto’s grand vision. With a more crypto-friendly US administration,  high-performance chains capable of handling global traffic, growing stablecoin adoption, and traditional finance pushing into RWA tokenization, the stars have aligned for blockchain technology to prove its worth. Yet a troubling reality is that even after years of innovation and billions in investment, we still lack answers to fundamental questions about mass adoption, user numbers, and meaningful organic usage.

While the industry often blames poor UX, speculation-driven culture, and regulatory uncertainty; significant progress has been made in these areas. What’s seldom addressed is the fundamental crisis at the heart of crypto: the alarmingly small number of live applications and their sluggish development pace.

In theory, an open, permissionless system should spawn applications faster than gatekept app stores. This staggering gap with traditional app stores hosting over 500 times more apps, despite their gatekeeping, highlights a critical problem. If our permissionless ecosystems truly offered advantages, we should see explosive application growth, not stagnation.

This paradox demands our attention.

Even more striking is that deploying tokens has become remarkably simple, but building usable applications remains fairly complicated. This “token first, app market fit later” paradigm has created an ecosystem that prioritizes speculation over utility, threatening the long-term viability of the entire system.

On the other hand, composability is often hailed as a cornerstone of crypto and DeFi, promising seamless integration of protocols and enabling developers to build powerful apps by combining modular components. However, the current market structure again contradicts this idea. Fragmented layer-1 and layer-2 ecosystems create compatibility issues, while inadequate tooling, elevated audit costs, and timelines deter developers from experimenting with highly composable designs. Security risks further erode trust, as composable systems amplify vulnerabilities; a single exploit in one protocol can cascade across interconnected apps. All of these render composability more ideal than practical, and leave crypto’s complete potential unrealized.

The industry’s future hinges on experimentation, collaboration, and ideation. If we commit to creating novel products rather than perpetuating the copy-paste trend, we dramatically increase our chances of discovering applications capable of crossing what Geoffrey Moore famously called “The Chasm” into mainstream adoption. But this window of opportunity won’t stay open forever.

Bottlenecks in Blockchain Development

For developers in crypto and especially DeFi, the development landscape bears little resemblance to web2’s rapid iteration cycles. Instead of agile sprints, they navigate a technical obstacle course that transforms promising ideas into extensive year-long endeavors (Eigenlayer took 22 months to introduce slashing).

They face a triple challenge: understanding nuanced blockchain frameworks, building intricate smart contract interactions, and running custom infrastructure just to maintain cross-protocol connections. The promise of “permissionless composability” often ends up as a technical hurdle in practice.

This complexity transforms innovative teams into integration specialists that spend precious development time debugging protocol interactions rather than building features users actually want. Meanwhile, the same permissionless nature that was supposed to accelerate innovation creates an open door for hackers, with state-sponsored actors like Lazarus targeting crypto projects time and time again. The resulting development timelines stretch from months into years, with every line of code requiring paranoid scrutiny.

The Security Tax

Building in DeFi is akin to an endurance challenge for smaller teams. Smart contracts form the backbone of everything, and even minute vulnerabilities can hemorrhage millions in seconds. This reality demands exhaustive testing of every logic path and external integration.

Security audits aren’t optional luxuries but have become a necessity for attracting any meaningful TVL and building confidence in liquidity providers. Top security and auditing firms can command over $50K-$200K+ per audit, with large codebases pushing that ceiling even higher. And this is a process that teams can’t rush through: so you’re looking at a 1-3 month ordeal spanning multiple rounds, often with several firms cross-checking each other’s work.

This creates a formidable barrier to entry, especially for early-stage teams that are bootstrapped or still in the process of raising funds. In most cases, they’re essentially funding a specialized security army before getting a mainnet transaction. 

It doesn’t stop there. Post-audit, the security demands continue. Bug bounty programs on platforms like Immunefi become permanent fixtures, with payouts ranging from $1,000 for minor issues to eight-figure rewards for critical vulnerabilities (Wormhole Uninitialized Proxy Bug ~ $10mn). Then there’s the perpetual vigilance required – threat monitoring, smart contract upgrades, and vulnerability patching. This endless “stay sharp or get rekt” cycle further stretches already extended development timelines.

More Chains, More Pains

While we believe in the incoming multichain future, we rarely acknowledge the exponential complexity it introduces. Each blockchain brings its unique technical DNA, different gas mechanics, security models, and development environments. Code portability is largely a myth, and developers must adapt, test, and secure their applications for each target chain. Most “chain abstraction” solutions are perpetually just over the horizon but never quite arrive with the full feature set needed for truly cross-chain apps.

These technical hurdles have undermined app development to a severe degree, but they’re only part of the story. The economic incentives themselves are fundamentally misaligned.

Misaligned Economic Incentives: The L1/L2 Premium

Beyond technical hurdles, the economic incentives themselves are fundamentally misaligned. Market dynamics consistently reward infrastructure over applications, with launching an L1 or L2 chain offering the fastest path to astronomical valuations.

Consider the pattern: Uniswap launched an L2, Ethena is building an L1, and dYdX migrated to its own chain, which are all in some capacity pursuing the “L1/L2 premium.” Meanwhile, application-layer protocols like GMX, Pancakeswap, and Lido struggle to capture comparable valuations despite generating real revenue. The market systematically values “ecosystem potential” over demonstrated business success.

This creates a brutal disadvantage for application-focused teams, who struggle to secure capital for growth despite building products people actually use.

But a change has been occurring. For the past 14 months, app revenue has consistently surpassed protocol revenue and currently represents approximately 80% of total fees earned. The industry is gradually recognizing that crypto’s true winners will be successful applications that solve genuine problems and attract real users. Applications have sustainable revenue potential that outlasts the ephemeral valuation spikes of underutilized chains.

Learning from Traditional Software’s Evolution

Many of blockchain’s development challenges mirror what the traditional software industry once faced. Yet conventional software development has maintained remarkable momentum, consistently innovating despite similar obstacles. The critical difference has been purpose-built tools (Zapier, Postman) that systematically eliminate technical bottlenecks.

Take Zapier as a prime example. By providing seamless connections to over 5,000 applications, Zapier fundamentally transformed how integrations work. What once required weeks of dedicated coding to manage APIs, authentication protocols, and complex data flows now takes minutes through a visual interface. This dramatic simplification doesn’t just save developer time, it fundamentally changes the scope of what is possible.

The ultimate beneficiaries are the end users. Applications become feature-rich, integrating seamlessly with tools people already use. They’re more reliable, with fewer integration-related bugs.

By removing this bottleneck, tools like Zapier enable developers to create software that delivers genuine value and exceptional applications that consistently exceed user expectations.

This is precisely what crypto and DeFi developers need right now. Enter Enso.

Enso is built to directly address the technical bottlenecks, simplifying smart contract integration, substantially cutting down the audit overhead, and streamlining multichain deployment. The goal is clear: lower the barriers to entry, accelerate development lifecycles, and realign incentives toward building applications people actually want to use.

More applications mean more attempts at discovering the elusive killer use case. Think of it as a probability game. When you throw a single dart, you might hit the board or miss entirely. But throw a handful of darts, and your odds of hitting the board increase dramatically. Rapidly releasing multiple crypto apps works similarly, more attempts mean more data to refine the next generation of apps and a higher probability of a breakthrough success.

Enso

Enso is blockchain shortcuts.

Most readers will be familiar with the idea of DeFi money legos, where protocols integrate with each other and primitives stack to create increasingly complex yet powerful applications. Enso takes this concept to its logical end state, offering a generalized library of these legos. Any blockchain function should be effortlessly combinable to create user and token flows that could otherwise demand weeks or even months of development time and specialized expertise.

To understand the transformative potential, think of Enso as a chef’s organized arrangement of ingredients and tools that turns chaotic cooking into a functioning professional kitchen. Chefs don’t harvest their own vegetables, mill their own flour, or forge their own knives. Instead, they assemble the finest pre-prepared components, allowing them to focus entirely on creating extraordinary culinary experiences. True innovation happens when these elements combine, not when reinventing each ingredient from scratch.

This is precisely what Enso shortcuts deliver for blockchain apps. Just as chefs combine quality ingredients to create signature dishes, shortcuts enable developers to build well-integrated onchain apps without rebuilding the fundamental components. Need token swapping functionality? There’s a shortcut for that. Want to integrate decentralized storage? There’s a shortcut for that. Looking to enable cross-chain transactions? There’s a shortcut for that.

At their core, shortcuts are pre-built, production-ready actions that abstract away the underlying complexity of blockchain interactions. They transform what once required specialized knowledge and significant development resources into accessible building blocks that any developer can deploy with confidence. This lets them focus on the unique components that define their application’s success.

The above simplification represents a major shift in blockchain development. Instead of managing individual integrations across multiple protocols and chains (a tedious process) that typically consumes months of engineering time, developers can utilize Intents to accelerate development and also reduce security surface area.

The Shared Network 

Enso’s Shared Network State is aimed at aggregating and storing smart contract interactions across multiple chains in a unified data layer. With this layer, Enso can enable optimized execution of intents by abstracting the complexities of integrations that have historically bogged down developers. 

For developers building on this shared network, the multichain landscape transforms from a fragmented maze into a singular cohesive ecosystem. What once appeared as isolated silos now functions as a single interconnected system. Simplified interactions with a wide net of smart contracts across protocols can reduce development time by an order of magnitude.

These developers additionally get robust security in their integrations and consistent data handling that ensures user interactions remain protected through the Shared Network. The shared network effectively dismantles the critical barriers that have throttled app layer innovation: ecosystem fragmentation, security vulnerabilities, and integration scalability challenges.

At its heart, the Shared Network maintains a real-time state of smart contract relationships across blockchains. This valuable data undergoes careful organization into standardized formats, ensuring both compatibility and intuitive access. The system also maps optimal pathways for executing these intents, considering historical performance and current network conditions. 

Before the execution of an intent, validators ensure the accuracy and security of this data, implementing checks to maintain data integrity, thus providing a simple framework for developers to interact with blockchains efficiently. Enso Network utilizes two fundamental building blocks in the creation and settlement of user intents: Actions and Shortcuts.

This modular design mirrors how modern software development evolved from low-level coding to component-based architecture. Actions provide the atomic operations that can be combined into powerful Shortcuts, allowing developers to implement sophisticated workflows.

When a user submits an intent, such as “maximize yield with my stablecoins,” the Enso engine springs into action, identifying precisely which Actions will fulfill this goal. These Actions are thoughtfully bundled into Shortcuts that execute as a single transaction, guaranteeing the user receives the exact, desired outcome. Currently, developers can integrate both Actions and Shortcuts through Enso’s centralized APIs and SDK.

The Enso Engine

The Enso Shortcut Engine functions as the intelligent bridge between users and blockchains. The fundamental elements are intents, which require users to submit desired outcomes rather than explain the prescriptive steps. Unlike traditional transactions that depend on specific paths, intents remain path-independent, offering flexibility in delivering user needs.

Intents by themselves are nothing more than user requests. There is no guarantee for execution of these user requests. The goal of building systems like Enso is to take user requests and provide provable execution paths for them. Shortcuts convert abstract intents into executable transactions, solving the challenge of turning “what users want” into “what blockchains can process.”  

The Enso engine abstracts all onchain data and executables to a shared infrastructure, eliminating manual blockchain or smart contract integrations. Without shortcuts, intents and chain abstraction would remain theoretical constructs. Through this shortcuts-based execution model, Enso dramatically improves accessibility, allowing developers to build more. The focus shifts from ‘how’ to ‘what’, freeing teams from implementation details and letting them concentrate on creating what matters: product, community, and growth.

The Centralized API

Enso’s flexibility is also visible through its support for both Externally Owned Accounts (EOAs) and Smart Contract wallets. Applications designed for EOAs can leverage Enso for all tokenized interactions, while applications enabling Smart Wallets can utilize Enso for both tokenized and non-tokenized interactions. This distinction matters because some DeFi protocols like Liquity don’t generate tokenized position representations.

When using a contract account, both tokens and state are stored within the contract itself. For instance, if a user borrows on Euler and then leverages the borrowed assets, the borrowed tokens and leveraged position remain managed within the contract account.

Developers can integrate Enso API directly into their apps. Enso APIs cater to different purposes bundled together.

• Router API: Finds optimal paths for DeFi operations (swaps, lending, farming, LPing) and returns executable transaction data.
• Bundler API: Combines multiple DeFi actions into a single transaction through a minimal smart wallet, offering gas savings by batching.
• Protocol and Standards API: Provides comprehensive information about protocols and available actions for developer integration.
• Metadata API: Delivers DeFi asset data, including pricing, composition, yield metrics, and wallet balances with powerful filtering options.

Out of these, the Router and Bundler APIs play the most important roles in the execution of user intents, whereas the other APIs make it easier for developers to integrate new applications.

Network Participants

The Enso Network needs three key participant groups to function as per its goals: 

Action Providers

Action Providers serve as the architects of Enso’s foundation, publishing standardized smart contract abstractions that form the network’s building blocks. These specialized developers craft elegant execution paths for fundamental functions like lending, swapping, and staking. They are also expected to optimize each interaction for reduced gas costs and lightning-fast execution. Through rigorous testing and validation, Action Providers ensure these interactions maintain ironclad security.

The workflow of Action Providers involves:

1. Action Creation: Developers create modular contract abstractions that represent specific DeFi actions (e.g., swapping, lending).
2. Submission and Validation: Submitted actions undergo validation by the validator network to ensure security and efficiency.
3. Optimization and Integration: Once validated, the actions are optimized for the Enso network. Optimization and integration also require action providers to monitor protocol changes and update abstractions accordingly to maintain compatibility.

Action Providers are rewarded for their work through a system that meters the usage and effectiveness of their abstractions, which are used by Graphers. The most effective and frequently used actions are compensated more generously, promoting the creation of high-quality contributions.

Graphers

Graphers function as Enso’s solution builders or solvers, constructing sophisticated algorithms that transform user requests into executable bytecode by intelligently combining smart contract abstractions. These specialized participants interpret user intents, identify ideal interaction patterns, optimize execution paths by balancing transaction costs against speed, and continuously refine their algorithms for maximum efficiency. 

Think of them as universal solvers capable of navigating the entire universe of available onchain interactions. Validators then evaluate Grapher solutions for both accuracy and security. The workflow of Graphers involves:

1. Intent Reception: Users submit an intent, specifying desired onchain outcomes such as asset swaps, lending, or staking.
2. Analysis and Computation: Graphers analyze the shared network state to identify available interactions across supported blockchains.
3. Solution Proposal: The optimal execution pathway is proposed and submitted for validation.
4. Validation and Execution: Once validators approve the proposal, the transaction can be executed onchain.

Graphers earn rewards through a competitive system that directly correlates compensation with solution efficiency. These payments are derived from a portion of the consumption fees paid by network users.

Validators

Validators are Enso’s security layer, validating proposed solutions for both security and efficiency. In exchange for this service, they earn a share of network fees. Their responsibilities include verifying Grapher-proposed solutions for accuracy, validating transaction states against current blockchain conditions, participating in the consensus to determine optimal execution paths, enforcing robust security to prevent exploitation, and approving transactions only after all validation criteria have been satisfied.

To qualify as Validators, participants must stake ENSO tokens, demonstrate technical proficiency in maintaining reliable infrastructure, and adhere to stringent security standards. A carefully designed slashing mechanism protects the network by penalizing misconduct.

How are Abstractions added to the network?

A new abstraction submission goes through several steps to ensure its valid entry to the network, which requires coordination between the action providers and validators.

1. Submission: Action Providers submit an action proposal.
2. Action Provider Validation: Validators verify that the Action Provider is registered within the onchain providers list.
3. Parsing: Action message data is parsed into an Action Type format, converting relevant values into the Position Type format.
4. Definition Retrieval: The Action Provider’s indexing infrastructure interfaces with the network to retrieve the action definition.
5. Transaction Generation: Bytecode is generated from the action definition.
6. Simulation: The bytecode is simulated to ensure the outcome aligns with the expected position behavior.
7. Onchain Validation: Positions are validated and stored onchain, with any missing data modified as needed.
8. Storage: The Action is stored onchain as part of the network map.
9. Action ID Emission: An Action ID is emitted to finalize the process.

Once these steps are completed, the abstraction becomes part of the Enso Network map. It is then available for use in generating solutions for consumer requests.

How does Intent Execution take place?

To fulfill intent requests, Enso’s network operates through three core components – Request, Solution, and Settlement – managed by network participants. It’s easiest to visualize the process like visiting a slightly modified fine-dining restaurant. Beneath Enso’s simplicity lies a sophisticated network architecture that coordinates between various participants to fulfill user intents efficiently.

The Request <> Placing Your Order

The process begins when the user submits a Request to the network, specifying their desired outcome and requirements. This is like telling a restaurant: “I want something spicy with meat that pairs well with this wine”. Rather than ordering a specific dish from the menu, you’re expressing your intent (swap tokens, enter a yield-bearing position) without dictating the exact implementation.

The Solution <> Kitchen Competition

Validation of Order Format

First, the validators (think of them as restaurant hosts for now) verify that your request follows the proper format. They check if the intent is clear and whether all required parameters are provided. Once validated, they propagate the request into the network’s mempool, i.e. the kitchen’s order system, where pending requests await processing.

Competing Graphers Design Solutions

Multiple Graphers (like competing chefs) receive your request and begin crafting potential solutions. Each Grapher uses their proprietary algorithms (cooking techniques) to determine the most efficient execution path using the available actions (ingredients) in the network. The key requirement: any proposed solution must be expressible as bytecode to be considered valid. Each completed solution is tagged with the corresponding IntentID, linking it to the user request.

Rigorous Quality Testing

Validators now perform their second role (as food critics), simulating each proposed solution by:

1. Forking the target settlement chain with its most recent state
2. Executing the bytecode to confirm that it can run without errors
3. Verifying correct state transitions by calling ViewFunction helpers embedded in each action
4. Running additional custom modules for balance checks, overrides, delegate calls, and other security measures

This meticulous testing ensures that what users receive will meet their expectations and function properly when executed.

Selecting the Winner

After individual validation, each validator reports their findings back to the mempool with both the IntentID and SolutionID. The network then selects the solution, offering the highest dollar output at the lowest execution cost, i.e. maximizing value while minimizing fees (best dish according to critics).

All rejected solutions are cleared from the mempool, operating as an efficient caching mechanism that prevents unnecessary network bloat. The winning solution is then presented to the user for execution.

The Settlement <> Serving Your Meal

Once you approve the proposed solution, it’s executed onchain, delivering your desired outcome in a single transaction. Settlement options include Router (for EOAs), Delegate (for smart accounts), or Enso Wallet deployment.

What began as a simple intent (“I want to swap Token A for Token B while minimizing slippage”) results in an optimized, validated transaction delivered for execution — without requiring you to understand the complex inner workings of multiple DeFi protocols or manage multiple sequential transactions yourself.

Network Revenue and Incentives

The Enso Network employs an incentive mechanism that aligns the payouts of its three key participant groups: Action Providers, Graphing Providers, and Validators with their contribution to the network. This helps the network ensure security, high-quality contributions, and efficient operations through its fee system.

The incentive flywheel is simple yet highly effective. Action Providers’ fee-sharing model directly incentivizes the creation of high-quality, secure, and efficient abstractions that others will want to use. Graphers operate in a competitive environment where they consume action data, build execution paths, and submit these routes to the network. Validators play multiple critical roles and thus receive fees for their essential work in securing the network and validating solutions. Staking and Slashing for Graphers and Validators help ensure a minimum service quality for end users.

This interconnected system is aimed at supporting a self-sustaining economy at scale, where each participant is financially motivated to perform their role effectively. This results in a network that delivers value to users and developers, leading to higher adoption and fee income, which can be further utilized to incentivize the participants to improve the abstractions coverage, enhance uptime, and reduce latency.

As Enso operates on many chains, the generated solutions will collect fees embedded into the bytecode used for execution. Instead of a system that bridges all generated fees back to a singular Enso-controlled address, each chain will have an auction where bidders can bid an amount of Enso tokens to have the right to claim the fees collected on the chain. This mechanism is similar to Euler’s fee flow auction that has led to the conversion of about $380k of fees into EUL token buybacks.

Enso tokens acquired via these auctions, along with network rewards, will be distributed among the network participants based on their contributions, such as abstraction consumption, winning solutions, and validation.

Tried and Tested: Adapting The Graph’s Incentive Framework for Enso

Enso shares several important economic design principles with The Graph Protocol, which has established itself as a tried and tested indexing protocol. Both systems employ multi-participant networks with specialized roles and a fee-based incentive structure that has proven effective in practice by the Graph.

Role-Based Participation: Both protocols divide network responsibilities among specialized participants. The Graph uses Indexers, Curators, and Delegators, while Enso employs Action Providers, Graphing Providers, and Validators. These role divisions create efficient specialization while distributing work across the network.

Fee-Based Incentive Structure: Both protocols utilize transaction and usage fees to reward participants. In The Graph, query fees flow to Indexers who maintain subgraphs, similar to how Enso’s Action Providers receive usage fees when their abstractions are utilized in solutions.

Competitive Optimization: Both systems encourage continuous improvement through competition. The Graph’s Indexers compete to provide the most reliable and fastest subgraph data, while Enso’s Graphers compete to deliver optimal solutions, both driven by the potential to capture greater fee revenue.

Validation Economics: The Graph’s validation mechanism via dispute resolution and slashing conditions parallels Enso’s validator incentives, where both earn rewards for ensuring network integrity and accuracy.

Proven Model with Enhancements

The Graph Protocol has successfully demonstrated the usage of the incentive flywheel since its mainnet launch in Dec 2020, processing billions of queries and maintaining a vibrant ecosystem of participants. This success provides a strong foundation for Enso, which builds upon and expands The Graph’s approach.

The model works because it:

1. Aims to align economic incentives with network health
2. Rewards quality contributions proportional to their usage
3. Creates natural competition that drives innovation
4. Distributes revenue fairly among all contributing parties

By adopting these proven tokenomic ideas, Enso builds upon a foundation that has already demonstrated market viability. However, Enso represents a crucial evolution beyond The Graph’s capabilities. While The Graph provides only data fetching services, Enso delivers both data fetching and transaction execution.

This dual capability of data plus execution gives Enso a significant edge. For example, a social platform like Lens Protocol would need to fetch user data (e.g., profiles, posts) and execute actions (e.g., collecting post NFTs, posting content on-chain). Using a tool like The Graph, Lens could fetch data but rely on separate infrastructure for transaction execution requiring them to juggle multiple integrations. With Enso, they could handle both tasks seamlessly via a single API, using Shortcuts to query data and execute actions like NFT minting in one streamlined workflow. This makes Enso a go-to choice for protocols seeking simplicity and scalability.

The addition of the execution prowess is also important for Enso’s economic sustainability. Despite The Graph’s success, it frequently distributes 15-100x more in rewards than it collects in fees per epoch. Transaction execution services can command higher fees than mere data queries, with users already demonstrating willingness to pay upwards of 1% per trade to Telegram bots and trading terminals. This fundamental difference positions Enso for stronger economic performance by capturing user willingness to pay for better execution.

Enso in Action

Targeted DeFi Campaigns: Royco and ZKsync Ignite

Most readers could’ve interacted with the Enso Network for the first time during the BoyCo campaign. Royco, coupled with Bera incentives, did really well for bootstrapping DeFi TVL. Underneath the surface, it was Enso shortcuts that processed $3.1B for Boyco. The campaign’s success can be attributed to a variety of factors, but something that is underappreciated is how users could migrate their liquidity to a simple or complex DeFi position on another chain with a couple of clicks.

Similarly, Enso shortcuts powered the backend for ZKsync Ignite, the incentive program along with Merkl to bootstrap liquidity on the Elastic Chain. Over 300m ZK tokens were rewarded to users who provided liquidity for key token pairs, traded on selected protocols, and supplied assets to lending markets with one-click deposits into pools. Increasing participation of users in such campaigns is attributable to the reduction in friction for an average user.

Enso, combined with incentive markets like Royco, is very similar to the SEO and ad space auction unlock moment for web2. How we see this growing further is that protocols will figure out the list of wallets that they’d want to onboard as liquidity providers. Each user signing into an ‘incentives & yield’ frontend will be shown custom reward opportunities or first-come, first-served yield opportunities to select from. This product by itself is insufficient and will require “Shortcuts” to make the user experience simple enough to succeed at a larger scale.  

Single Click DeFi

Active DeFi participants know the hurdles of migrating positions. Let’s say we are migrating stables from Ethereum to deploy liquidity in a pool on Aerodrome. The current flow of the user includes approving and withdrawing assets from the lending protocol, using a bridge to send funds over to Base, swapping into the necessary ratio of assets for deploying into the LP pool, and then finally depositing liquidity. 

It is completely unreasonable to expect new users to jump through the same hoops and hurdles. It would be much easier if protocols themselves submitted their actions, shortcuts as abstractions on the Enso network. Once an abstraction is added, users will be able to swap into the tokenized position with a single click. The Enso widget allows one to swap into a tokenized position across chains and can be integrated into any frontend.

Unichain recently introduced significant incentives (~$45 million between Uni v4 and Unichain), which aim to draw from the $3 billion in AMM liquidity to migrate to Uni v4 on Unichain. A large user base of liquidity providers (LPs) is passively participating in major Uni v2 and v3 pools across various EVM chains. These LPs can unlock Unichain’s incentives and simply multiply their earnings by migrating their positions to Uni v4, but this is a complex 9-step process, requiring manual withdrawals, cross-chain bridging, and Uniswap v4 configuration. This would understandably deter even experienced users.

But adding Enso into the mix changes things. UniswapLP Migrator has been developed with Stargate and LayerZero to simplify this into a single transaction. LayerZero provides trust-minimized cross-chain communication, Stargate offers liquidity transport with guaranteed finality, and Enso manages DeFi execution across chains. Together, they allow LPs to migrate Uni v2 and v3 positions from any EVM chain to another Uni v4 instance effortlessly. The solution is live at Uniswap Migrator.

User-Friendly DeFi

User-friendly DeFi is a further evolution of the above-described single-click DeFi. The widget is a good front-end for users who know exactly what they want to do. But this doesn’t solve the discoverability problem in DeFi. That is where we will see curated frontends developed in little to no time using AI-assisted tools and powered by Enso shortcuts at the backend. Think AI-assisted portfolio management tools and single-click yield migration tools that find the best yield opportunities for the assets users hold.

This interface represents one step in the next evolution of DeFi usability. Intelligent systems that not only execute transactions but also actively help users discover opportunities. By presenting current positions alongside higher-yield alternatives with clear APY comparisons, Enso-powered interfaces can eliminate the research burden that previously deterred mainstream users.

What’s on the roadmap for Enso?

The future of Enso is about expanding capabilities, protocol integrations on the network, and providing interoperability across blockchains with higher reliability and in a trust-minimized manner. Currently, the network is going through its initial launch phase.

Phase 1: Centralized Service (Now)

At this stage of the network, Enso operates a centralized service alongside the network to ensure stability and functionality. Validators still simulate bytecode solutions to verify their outcomes. Developers can provide actions and contribute through the centralized service, allowing shortcuts to exist with the much-needed stability during these early stages.

Phase 2: Completely Permissionless and Decentralized System

Once the network has proven its stability, the transition towards a permissionless model begins. The roles of action providers and graphers will be opened up to more participants, marking the move towards a decentralized ecosystem. The coverage will expand beyond the EVM to include support for other blockchain frameworks, such as the SVM and Move Virtual Machine (MVM), making the network more appealing to a larger cohort of developers.

For crypto’s eventual success: there will be millions of apps and interactions available to a user at any given point in time. 

If Action providers and Graphers on Enso aren’t able to provide the abstractions or solutions within this expanding universe, then Enso will stagnate or decline. We believe the goal of the system should be to become equivalent to DeFiLlama for TVL data or CoinGecko for token price, i.e. every new app should want to provide shortcuts on Enso as part of their launch plans.

Phase 3: Monetization and Defensibility

Enso is well-positioned to restore composability to crypto applications, giving it a first-mover advantage in a critical space. This section explores how Enso can further monetize its platform and enable apps using its services to generate revenue, while also building strong defensibility through network effects and data aggregation.

Enso’s core monetization model is straightforward: it earns fees for each user request processed through its network services. As transaction volumes grow, this fee-based revenue stream scales naturally. Looking ahead, Enso could introduce priority fees, allowing users to pay a premium for faster access to Graphers and their solutions, particularly for time-sensitive transactions.

Additionally, Enso could explore a transaction fee model, such as a one basis point (0.01%) fee on transactions facilitated through its platform. For context, a similar fee structure applied to Boyco vaults, which processed over $3 billion in volume, could have generated $300k in revenue. To incentivize dApps, Enso could share a portion of these fees, enabling reinvestment in their products and ecosystems, which would further drive transaction volumes through Enso. We have seen similar incentives helping shape a network of applications with Sonic and its fee monetization, which has generated ~$400k for Sonic dApps.

For developers, Enso could adopt a freemium subscription model for its API and SDK integrations. Small projects could access basic features for free, while larger projects with higher transaction volumes would pay tiered subscription fees. This flexible approach ensures accessibility for early-stage developers while capturing value from scaled operations. Enso’s team has ample room to experiment with pricing and fee structures to balance network growth with sustainable revenue.

By aggregating transaction data, Enso’s intent engine should become increasingly sophisticated, enabling it to estimate user behavior and intents with greater accuracy. dApps could leverage these insights to: 

• Identify and attract their target users more effectively.
• Design seamless, single-click strategies to onboard target users.

This data-driven approach can empower dApps to optimize their user acquisition and retention strategies, ultimately boosting their own revenue potential. While Enso’s moats aren’t clear at first glance, its defensibility lies in powerful network effects. As the leading solution for composability, Enso attracts developers by supporting the widest range of chains and protocols. New developers and protocols are incentivized to choose Enso to tap into its extensive network, creating a virtuous cycle of adoption. This snowball effect strengthens Enso’s position as the go-to platform for composability.

The more apps and transactions Enso facilitates, the more data it collects, further refining its intent networks’ capabilities. This data advantage enhances Enso’s value proposition, making it harder for competitors to catch up. By maintaining its first-mover lead and continuously expanding its network, Enso can solidify its dominance.

Conclusion

The only way to see innovation in this space is to make building so easy that every good idea becomes a product.

Crypto stands at a critical crossroads where all the technical pieces needed are here, and regulatory clarity is improving. The industry’s success now hinges on delivering apps that solve problems and provide value for real users. Enso fundamentally has changed the equation by transforming what was once a lengthy development process into something more manageable and accessible to all.

Evidence of this transformation is already visible. Enso shortcuts have processed over $4 billion in volume by abstracting actions across EVM ecosystems via initiatives like Boyco and ZkSync Ignite. The simplification of elaborate processes like Unichain’s LP migration shows how Enso is removing critical barriers.

For developers, Enso means liberation from technical complexity to focus on what matters: creating exceptional user experiences. For protocols, it represents unparalleled composability and user acquisition channels. For users, it delivers more intuitive applications that finally make crypto’s benefits accessible without its traditional complexity and taxation.

As adoption of Enso grows, we can expect to see more apps launching across the ecosystem, expanding integrations and experimentation in previously unexplored use cases, and the emergence of hybrid applications bridging web2 user experience with web3 capabilities. This is about better apps that can finally reach users without being strangled by technical constraints.

Signs of faster product development are already emerging with Enso’s offering. Builders are seeing dramatically reduced time-to-market, with concrete examples demonstrating exceptional efficiency gains:

• Onplug successfully recreated in just 2 days what had previously taken them 7 months to build manually after integrating with Enso.
• The Otomato team reported a similar transformation when they started completing integrations that took them a week earlier in hours and realized that they could now do many more integrations.

With the middleware tooling layer sorted out, it’s not too ambitious to envision Enso becoming part of the toolkit for web2 businesses to tap into crypto rails and start shipping hybrid products.

The question for everyone in the ecosystem is simple: In a world where technical barriers no longer constrain what’s possible, what will you build?