​
The Problem You Know Too Well

You’ve built an amazing DeFi feature. It works perfectly… in your tests. Then real users try it:
1

Transaction 1

“Please approve spending”
2

Transaction 2

“Now execute the swap”
3

Fund wallet

Needs to fund wallet with gas on destination chain
4

Transaction 3

“Approve on the destination chain”
5

Result

User closes tab
A customer lost due to the limitations of current Web3 UX. Biconomy is here to solve it!

​
Enter the Modular Execution Environment

MEE is Biconomy’s infrastructure that lets you orchestrate complex blockchain operations with a single user signature. Think of it as a transaction compiler - you write high-level intents, MEE handles all the messy blockchain details. 
// Multiple transactions, multiple signatures
await token.approve(spender, amount)  // Sign 1
await protocol.deposit(amount)         // Sign 2
await bridge.transfer(chainB, amount)  // Sign 3
// ... user already left

​
How It Works

MEE operates through a network of orchestrator nodes that:
1

Accept Signature

Accept a single signature from the user
2

Execute Operations

Execute multiple operations across chains
3

Handle Dependencies

Handle all timing and dependencies (bridges, async operations)
Your users sign once. MEE handles everything else.

​
Core Capabilities

​
1. Composable Instructions

Chain operations together like Lego blocks. Each instruction can use outputs from previous ones. 
const instructions = [
  swap(USDC → USDT),              // Output: USDT amount
  deposit(/* uses USDT amount */), // Output: aTokens
  bridge(/* uses aTokens */)       // To another chain
]

​
2. Universal Gas Abstraction

Users can pay with any valuable token - not just native gas tokens.

Stablecoins

USDC, USDT, DAI

LP Tokens

Uniswap/Curve positions

Yield Tokens

aUSDC, stETH

Any ERC-20

Literally any token with value

​
3. Cross-Chain Orchestration

Single signature, multiple chains. MEE handles bridge timing, confirmations, and execution. 
// This just works
await meeClient.execute({
  instructions: [
    operationOnOptimism,
    bridgeToBase,
    operationOnBase,
    bridgeToArbitrum,
    finalOperationOnArbitrum
  ]
})

​
4. Runtime Parameter Injection

Handle dynamic values that aren’t known until execution time. 
supply({
  amount: runtimeERC20BalanceOf({
    token: USDT,
    minBalance: parseUnits('100', 6)  // Safety constraints
  })
})

​
Why Developers Choose MEE

  • Write business logic in TypeScript
  • No smart contract deployments
  • Update logic without audits
  • Test locally with mainnet forks

​
Integration in 5 Minutes

1

Create account

import { createMeeClient, toMultichainNexusAccount, getMEEVersion, MEEVersion } from "@biconomy/abstractjs"

const account = await toMultichainNexusAccount({
  signer: userWallet,
  chainConfigurations: [
    {
      chain: optimism,
      transport: http(),
      version: getMEEVersion(MEEVersion.V2_1_0)
    },
    {
      chain: base,
      transport: http(),
      version: getMEEVersion(MEEVersion.V2_1_0)
    },
    {
      chain: arbitrum,
      transport: http(),
      version: getMEEVersion(MEEVersion.V2_1_0)
    }
  ],
})
2

Create client

const meeClient = await createMeeClient({ account })
3

Execute anything

const { hash } = await meeClient.execute({
  instructions: [...],  // Your orchestrated flow
  feeToken: { address: USER_PREFERRED_TOKEN }
})

​
The Bottom Line

Every signature you don’t ask for is a user you keep. Every chain boundary you hide is friction removed. Every gas token hunt you eliminate is a transaction completed.
MEE isn’t just infrastructure - it’s how you ship Web3 products that users actually want to use.

Ready to give your users superpowers?

Get started with MEE in 5 minutes