Intent Execution Layer (IEL)

Overview & Getting Started

Overview

IEL is a verification-first execution layer for safe automation.

Instead of giving agents, relayers, or apps direct authority over funds, IEL introduces a two-phase model:

  1. Actions are proposed as signed intents
  2. Intents are verified on-chain against explicit policy constraints
  3. Only verified intents can be executed by authorized executors

This separation of decision, verification, and execution makes automation testable, auditable, and safer by design.

IEL is built for teams automating on-chain actions who need execution to be bounded, observable, and replaceable — without trusting keys.

IEL is not a wallet.IEL is not a relayer.It is the execution membrane that sits between them.

Core Model

Intent
App/Agent signs
→
Verify
IntentManager
+ policy constraints
→
Execute
Authorized executor
→
Complete
On-chain tx

Two-Phase Execution

IEL splits execution into two explicit phases:

Phase 1Verification
  • An intent is submitted to the IntentManager
  • On-chain policy constraints are evaluated
  • If valid, an execution event is emitted
  • If invalid, execution halts permanently
Phase 2Execution
  • An authorized executor picks up the validated intent
  • Operations are reconstructed from emitted calldata
  • Transactions are executed on-chain
  • Completion is emitted and observable

Nothing executes unless it has already passed verification.

Policy-Driven Guardrails

Policies define what may execute, where, when, and how much.

Budget capsAllowed venues / protocolsFunction selectorsTime windowsDelegated signer scopes

Policies are enforced before execution, not during or after.

Executor Portability

Executors never have custody and never have discretion.

Any authorized executor can execute a verified intent — and apps can switch executors without migrating wallets or rewriting policies.

This prevents relayer lock-in and enables an execution market over time.

What's Live Today (v1)

LIVE

Networks

Local Hardhat / AnvilBase Sepolia (public demo)

Core Protocol

  • Policy-enabled smart wallets
  • Multi-policy per wallet architecture
  • IntentManager (on-chain verification)
  • Two-phase execution (verify → execute)
  • Delegated signing (agents / relayers)
  • V2 + V3 constraint system (Merkle leaves + policy headers)
  • TOCTOU protection via header binding
  • Executor-agnostic architecture

SDK

  • Wallet creation (counterfactual + deploy)
  • Policy creation with presets (trading, treasury, automation)
  • Agent clients: transfer(), swap(), supply(), withdraw()
  • Multi-operation bundles
  • Runtime abstraction (relayer / executor endpoint)
  • Typed error handling
  • Coupled and decoupled execution modes

UI Demo

  • Wallet + policy presets
  • Successful execution paths
  • Constraint failures (budget, venue, selector)
  • Agent attempts blocked by policy
  • Two-phase lifecycle visibility

Validation

E2E tests covering:

TransfersSwapsAave supply / withdrawExecutor portability (decoupled execution)

Explicitly Out of Scope (v1)

OUT OF SCOPE

This is intentional. The following are out of scope for v1 and should not be assumed:

Cross-chain routingFully permissionless executor networksOn-chain storage of full policy artifactsPrivacy-preserving executionMEV optimizationToken-based incentives

These are future extensions, not blockers to protocol validity.

What's Coming Next

PLANNED

SDK Extensions

  • Wallet discovery (listWallets(address))
  • Wallet + policy recovery / rehydration
  • Policy version history access
  • Relayer SDK packaging (hardening + observability)

Platform Layer

  • WalletOps Cloud (artifact backup, audit trails, recovery)
  • Enterprise attestations
  • Optional execution optimization / routing

Quickstart (Demo)

This demo shows the full two-phase lifecycle and constraint enforcement — not production throughput.

1Clone the demo repository

git clone <demo-repo-url>
cd iel-demo

2Set environment variables

cp .env.example .env
# Add RPC URL, private key, relayer endpoint

3Install dependencies

pnpm install

4Run the demo

pnpm dev

5Explore the UI

  • Create a wallet
  • Attach a policy preset
  • Execute an action
  • Trigger a constraint failure
  • Observe the two-phase lifecycle

Mental Model (TL;DR)

Apps and agents propose.

Policies decide.

Executors execute.

Wallets remain safe.

IEL makes automation safe, portable, and verifiable — without trusting keys or opaque relayers.