Policy infrastructure for autonomous execution

Intent Layer

Current status, architecture, and execution roadmap for Intent Layer.

“Intent Layer is authority infrastructure for autonomous agents — humans approve bounded policies, agents act within them, on-chain verification enforces the guardrails, and everything is auditable by default.”

Example: approve a $5k/month payroll policy; an agent can run payroll, but can't exceed budget or pay unapproved recipients.

Live on Base SepoliaPre-seed stageNo token required for v1

Proof:|Request live demo: Cloud-backed execution

Base Sepolia — All verifiedView on BaseScan

All contracts are deployed and verified; some are newly deployed so BaseScan may show limited event history.

What is this?

Intent Layer is a policy engine for execution.
It lets agents/software act, but only within human-approved limits (budgets, allowlists, time windows).
If policies don't match, nothing executes.

1. How Intent Layer Works

Intent Layer separates authority, decision, verification, and execution into distinct phases.

Single Mental Model

Cloud

Policies configured

→↓

Intent

Agent signs

→↓

Verify

IntentManager
+ policy constraints

→↓

Execute

Authorized executor

→↓

Complete

Receipts

Technical detail

┌──────────────────────┐
│ Intent Layer Cloud   │
│ (policies)           │
└──────────────────────┘
      │ 0. Configure authority
      ▼
┌────────────┐
│ Agent      │
└─────┬──────┘
      │ 1. Build + sign intent
      ▼
┌──────────────────────┐
│ IntentManager        │
│ (on-chain)           │
│                      │
│ • Verify constraints │◄── Policy headers
│ • Check budgets      │◄── Merkle proofs
│ • Enforce venues     │◄── Delegation rules
└─────┬────────────────┘
      │ 2. Emit validated event
      ▼
┌──────────────────────┐
│ Executor / Relayer   │
│                      │
│ • Reconstruct ops    │
│ • Execute tx(s)      │
│ • Emit completion    │
└─────┬────────────────┘
      ▼
┌────────────┐
│ Blockchain │
└────────────┘

Key idea

Nothing executes unless it has already passed on-chain policy verification.

This eliminates:

TOCTOU failures

Blind relayers

Agent key risk

Unbounded authority

Humans approve authority. Agents decide actions. Executors perform. Cloud observes and explains.(open executor market planned)

2. What's Live Today

Everything needed to create wallets, attach policies, and execute intents via Cloud is implemented on Base Sepolia.

v1 Implemented

Networks

Local Hardhat / AnvilBase Sepolia (public demo)

Core Protocol + SDK

Policy-enabled smart wallets
Multi-policy per wallet architecture
IntentManager (on-chain verification)
Two-phase execution model (validate → execute)

Delegated signing (agent / relayer execution)
V2 + V3 constraint system (Merkle leaves + policy headers)
TOCTOU protection via header binding
Executor-agnostic architecture

SDK + MCP

Wallet creation (counterfactual + deploy)
Policy creation with presets (payroll, trading, treasury)
Agent clients (transfer, swap, multiOp)
Cloud-backed runtime (ielSdk.cloud.connect)
MCP server (lets AI tools propose intents + read constraint failures)
Typed error handling

Cloud + UI Demo

Policy lifecycle API
Execution history + receipts
Budget tracking and observability
Agent-readable error responses

Execution retries + durability

UI Demo

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

E2E tests:transfers, swaps, Aave supply/withdraw, executor portability

Wallet discovery API (list existing Intent Layer wallets)Wallet recovery / policy rehydration APIManaged WalletOps Cloud (backup, attestations)Production relayer SDK (hardening + monitoring)Cross-chain routing

These are planned extensions, not blockers for protocol validity.

3. What's Coming Next

Near-term roadmap for SDK and Intent Layer Cloud.

Near-Term

SDK Extensions

Wallet discovery (listWallets(address))
Policy + wallet recovery / rehydration
Policy version history access
Relayer SDK packaging

Intent Layer Cloud Extensions

Policy request workflow (agents request authority expansion)
Enterprise attestations
Notification channels for approval requests
Template-based approvals (class-based authority grants)

4. Traction Plan & Investor Ask

We are intentionally starting with builders who already feel the pain.

Pre-seed

Initial Target Users

Agent builders

Want bounded autonomy without giving agents keys. Need deterministic, auditable authority constraints.

Autonomous finance teams

Rebalancing, DCA, yield ops. Need bounded authority + auditability.

Treasury / ops teams

Payroll, invoices, payouts. Need policy-constrained execution + lifecycle visibility.

The Business

Monetization

Intent Layer Cloud (authority lifecycle, audit, receipts)
Relayer SDK licensing
Enterprise policy attestations
Pilot + integration fees

Buyer

Agent builders, ops teams, and autonomous finance protocols

Initial Wedge

Bounded authority for agent-driven operations

Why We Win

Policies + lifecycle + portability + SDK-first distribution

What we're asking for now

Design partners to validate SDK ergonomics
Pilot integrations (small production scopes)
Feedback on Cloud authority lifecycle requirements
Looking for a lead or co-lead pre-seed and 2–3 design partners

Fundraise

Raising pre-seed to fund: SDK polish + 2–3 pilots + Intent Layer Cloud v1.

Funds used for:

SDK polish + docs
Intent Layer Cloud v1
Relayer SDK hardening
2–3 production pilots

90-day goal: 2 design partners + 1 pilot in production scope.

No token launch required for v1.

5. Competitive Framing

Intent Layer is differentiated by verification-first execution, a constraint language, and executor portability.

Why Now

Agents are arriving, but key custody is unacceptable.

Agents need bounded authority, not unlimited power.

4337 adoption makes policy wallets practical.

Why existing approaches fail

Agents + keys

Keys are binary authority
No preconditions or bounded behavior
One bug = total loss

The failure mode is unbounded authority, not malicious agents.

Safe / raw 4337

Give signature aggregation + account abstraction, but NOT:

Verified preconditions
Two-phase execution
Executor portability
TOCTOU protection
Multi-policy specialization

Intent Layer operates above wallets as an authority boundary.

Intent Layer's Moat

Constraint system (Merkle + policy headers)

Two-phase verification-first execution

Multi-policy per wallet

Executor portability

SDK-first distribution

Operational monetization (not protocol rent)

Competitors can copy contracts. They can't easily copy:

the constraint languagethe verification lifecyclethe developer workflowthe operational layer

Accumulating advantages over time:

Growing library of battle-tested policy presets
Real production workflows from pilot integrations
Institutional-grade audit trails + controls (Cloud)
Ecosystem standard for intent verification events

Summary

Intent Layer is not a wallet.Intent Layer is not a relayer.It is the authority boundary that sits between them.

Intent Layer is the authority layer that makes agent autonomy safe, testable, and portable.

Contact for Demo + Deck View Public Landing Page

For builders:Read Docs