Hey Elsa Hey Elsa
· 11 min read

HeyElsa —The Crypto Agent Layer ( Litepaper )

Elsa Overview

TL;DR

Elsa is the crypto agent layer that turns intent → action.

Users (and partners) issue goals; a multi-agent system plans, validates, and executes across chains safely, autonomously, and at scale.

Overview (What is Elsa?)

Elsa makes DeFi feel like typing a message.

Three surfaces, one engine:

Overview (What is Elsa?)

Elsa makes DeFi feel like typing a message.

Three surfaces, one engine:

What this litepaper covers (Preview)

Technical Architecture (Layered)

Bottom → Top

  1. Data & GroundingOn-chain state (nodes/indexers), oracles, curated KB; freshness checks & anomaly detection.
  2. Execution LayerPre-audited scripts, simulation, route selection (DEX/bridge meta-routers), MEV-safe submission, idempotency, receipts, telemetry.
  3. Agent LayerComposable specialists (Swap, Bridge, Yield, Risk/Hedge, Perps, NFT, Sniper, Alerts). First-party + hosted third-party agents with scoped permissions & SLAs.
  4. A2A Bus (Coordination)Pub/sub messaging, contract-net bidding, plan aggregation, reputation, fairness scheduling.
  5. Orchestration (Multi-LLM + Planner)Task classification → model routing (small/mid/large). Strategy synthesis, constraint solving, fallback/hedged inference.
  6. Intent Layer (NL Interface)Parsing, slot-filling, constraint capture, policy hints, multi-turn context & disambiguation.
  7. Safety & PolicySimulation gates, allow/deny lists, max-notional limits, geo/KYC hooks, verified inference (zkTLS/MPC-TLS).
  8. Cognitive CacheTEE-backed private memory of preferences, behaviors, outcomes; accelerates planning & personalization.
  9. ObservabilityTraces, metrics, audit logs, anomaly detection, circuit breakers.

How the three surfaces map onto the stack

Layers, Policies & Safety

Intent Layer

Role: Natural-language interface that converts user input into machine-readable intents with constraints.

Responsibilities

Inputs → Outputs

Key Components

Failure Modes / Handling

Orchestration Layer

Role: Decides how to satisfy an intent: routes to the right model(s), synthesizes a plan, assigns agents, and sets up A2A messaging.

Responsibilities

Inputs → Outputs

Key Components

Failure Modes / Handling

A2A Bus (Agent-to-Agent Communication)

Role: Contract-Net style coordination for multi-agent work; pub/sub plus scheduling and reputation.

Responsibilities

Key Components

Agent Layer

Role: Composable specialists that execute parts of a plan.

Core Agents

Interfaces

Execution Layer

Role: Turns approved plans into on-chain transactions safely.

Responsibilities

Outputs

Cognitive Cache

Role: Private memory for speed and personalization.

Contents

Controls

Benefits

Safety Layer

Role: Proves what we know, enforces what we allow.

Grounding

Policy Engine

Verified Inference

Simulation & Dry-Run

Observability

Role: Make intents→actions traceable and operable.

What’s tracked

Surfacing

Classifier Features (expanded)

Routing Policy (multi-LLM)

Grounding Pipeline

Verified Inference

Fallbacks & Hedging

Example Intent → Action (concise)

  1. User: “Bridge 2 ETH to Solana and stake for safest yield.”
  2. Intent Layer: intent.yield.optimize with amount=2 ETH, dstChain=Solana, risk=low.
  3. Orchestration: classify R2, route mid/large model → plan: {swap? no, bridge via Wormhole, stake Solana pool A}, SLAs.
  4. A2A Bus: RFQs to Bridge Agent + Yield Agent; award best proposals.
  5. Execution: simulate bridge + stake; private submit; collect receipts.
  6. Safety: ground rates/APY; enforce policy caps; attach proof.
  7. Observability: log trace; show user receipts + realized APY baseline.
  8. Cache: update prefs (Solana OK, low-risk yield).

Schemas (abridged)

Intent (v3)

{
  "verb": "yield.optimize",
  "objects": [{"asset":"ETH","amount":"2"}],
  "params": {"dstChain":"solana","risk":"low"},
  "constraints": {"maxSlippageBps":50,"deadlineSec":900},
  "profileRef":"cache://user/123",
  "policyScope":"retail.low",
  "version":"v3"
}

Plan (v2)

{
  "steps":[
    {"id":"s1","type":"bridge","route":"wormhole","from":"ethereum","to":"solana"},
    {"id":"s2","type":"stake","venue":"solend","asset":"SOL","policy":"lowRisk"}
  ],
  "dependencies":[["s1","s2"]],
  "sla":{"p95LatencyMs":30000},
  "fallbacks":[{"on":"bridgeFail","route":"portal"}]
}

SLAs / SLOs (suggested)

Policy Defaults (retail tier)

If you want, I can convert this into a Notion page export (as Markdown with toggles) or wire it into your existing data room structure.

Build once; get execution + safety + distribution.

Agent Manifest (example)

name: yield-agent
version: 1.2.0
capabilities:
  - chain: [base, ethereum, solana]
  - actions: [scan_yield, allocate, compound, exit]
sla: { p95_latency_ms: 1000, success_rate: 0.995 }
cost_model: { pricing: per-plan + per-exec }
permissions: { scopes: [simulation.read, protocols.write:yield, quotes.read] }

Why: multi-specialist coordination for complex workflows.

Excalidraw brief: circular cache feeding router with “known preferences”, “risk profile”, “recent strategies”.

Widget (drop-in)

SDK (agents & flows)

import { Elsa } from "@elsa/sdk";

const elsa = new Elsa({ apiKey: process.env.ELSA_KEY });

const intent = {
  type: "yield.optimize",
  amount: "500",
  asset: "USDC",
  constraints: { chain: "base", maxSlippageBps: 30 }
};

const plan = await elsa.plan(intent);
await elsa.simulate(plan.id);
const receipt = await elsa.execute(plan.id);

More users → richer prompts & outcomes → better finetunes → higher plan/exec quality → more partner conversion → more users.

Retail: “Bridge 2 ETH to Solana and stake best yield”

iFrame Widget

  1. Paste snippet, set partner key, theme/tokens/chains.
  2. Subscribe to callbacks for analytics/incentives.

SDK

  1. Install, create intents, plan/simulate/execute, display receipts.
  2. Apply policy templates (max notional, allow-listed routers, geo limits).

Host Your Agent

  1. Publish manifest, pass conformance tests, get sandbox scopes.
  2. Receive A2A tasks; earn per plan/exec.
POST /v1/intents
{
  "type":"swap",
  "user":"0x...",
  "params":{"sell":"ETH","buy":"USDC","amount":"1.0","chain":"base"},
  "constraints":{"maxSlippageBps":30,"deadlineSec":90}
}


GET /v1/plans/{intentId}
# returns steps, quotes, risk, agents, policy gates


POST /v1/execute/{planId}
# returns tx receipts, route, realized slippage, gas


mutation {
  createIntent(input:{
    type: YIELD_ALLOCATE,
    asset: "USDC",
    amount: "500",
    chain: BASE
  }) { id status }
}

Problem

Crypto is powerful but unusable at scale.

Most users don’t need more protocols — they need better execution.

Solution

Elsa introduces an AI-first execution layer.

Users express intent.

Elsa executes it.

Elsa abstracts complexity while preserving transparency.

Product Stack

B2C: Elsa Copilot

B2B: Elsa Infrastructure

Business Model

Elsa is usage-driven, not speculation-driven.

Revenue sources:

As execution volume grows, revenue scales naturally.

Token Overview

Parameter Value
Token $ELSA
Total Supply 1,000,000,000
Decimals 18
Network Base

$ELSA is a utility token, powering execution, inference, and access.

Utility of $ELSA

$ELSA is the economic backbone of Elsa.

Fee Discounts

Feature Access

Gas Abstraction

Inference & Execution

Utility scales with real platform usage.

Token Allocation & Vesting

Category Allocation Vesting
Team 7% 12m cliff, 24m linear
Foundation 34.490% 20% TGE, 10m cliff, 24m linear
Community 40% 20% TGE, 48m linear
Pre-Seed 1.4% 12m cliff, 24m linear
Seed 9.11% 12m cliff, 24m linear
Liquidity 8% 100% at TGE

Community-first allocation with long-term alignment.

Roadmap Snapshot

Up to Q2 2025 (Completed)

Q3–Q4 2025

2026

Design Philosophy

Elsa is built for scale, automation, and real usage.

Share Tweet Share Share Email

Read next