Mentra Agentic DeFi OS

Agentic DeFi OS

What is Mentra?

Mentra is the first Conversational DeFi Operating System on Base. You describe an intent in natural language — open a perp, swap a token, supply a vault, inspect trust — and Mentra maps that utterance onto a typed on-chain action without taking custody of funds.

The OS sits above protocol adapters (Veranta, Aerodrome, Morpho) and intelligence engines (trust, reputation, builder score). Agents execute through the same confirmation cards a human trader sees. Nothing is signed until you approve it in your wallet.

The fragmentation problem

Core problem solved: fragmented DeFi UIs. Instead of hopping across DEX frontends, perp terminals, and lending dashboards, you chat once. Mentra classifies the intent, runs pre-flight checks (min size, max leverage, slippage, oracle freshness), then presents a two-step confirmation card.

Next: Action Engine

Chat-to-trade & swap

Conversational Action Engine

The Conversational Action Engine is Mentra’s chat-to-execution path. Natural language is parsed into a typed ActionPayload (open, close, update TP/SL, swap, supply, borrow). Protocol adapters then simulate, quote, and — only after you confirm — submit via the connected wallet.

Intent classification

Intent classification maps natural-language prompts onto a closed set of typed on-chain actions. Unknown markets, sub-minimum collateral, or leverage above pairMaxLeverage fail in prose before a wallet popup appears. Last-referenced market is remembered across turns so “close 50%” resolves to the pair you just discussed.

// Utterance
"Long ETH with 5x on $100 USDC, SL 2% below mark"

// Classified payload (shape)
{
  kind: "open_position",
  protocol: "avantis",
  marketId: "eth-usd",
  side: "long",
  collateralUsdc: 100,
  leverage: 5,
  slPercent: 2
}

// Runtime path
AvantisAdapter.simulate → ActionTradeCard → approve USDC → sign tx

Veranta Protocol Integration

Conversational perpetual leverage on Veranta: open and close longs/shorts, set dynamic take-profit / stop-loss, and surface liquidation distance from mark, leverage, and maintenance math. Execution fees are quoted from live Pyth Hermes VAAs plus the Veranta trade adapter's getExecutionFee() so the overlay matches what the contract will charge.

• Markets: ETH-USD, BTC-USD, SOL-USD, DOGE-USD and the live Veranta catalog.
• Pre-flight: minimum $10 USDC collateral and pair max leverage from pairStorage.
• Oracle: Hermes latest + VAA bytes for updatePriceFeeds; bilingual EN/FA revert decoding on failure.
• After fill: mentra:trade-executed event refreshes portfolio positions.

Aerodrome Protocol Integration

Conversational token swaps on Base via universal routers. Mentra quotes the route, applies pre-flight slippage bounds, and will not submit a swap that exceeds the user’s stated tolerance. The same confirmation card pattern applies: review quote → approve token if needed → sign.

Morpho Protocol Integration

Yield optimization and conversational lending/borrowing vaults. Supply, withdraw, borrow, and repay are expressed as chat intents, then bound to Morpho market params and asset amounts in base units. The agent never guesses a vault that is not on the connected Base deployment.

Action Confirmation Cards

Confirmation cards implement a two-step security model. Step 1: USDC (or token) allowance approval to the protocol spender, exact amount when possible. Step 2: atomic contract execution (open market order, swap, or Morpho market call). Mentra never batches those two signatures into a single opaque “approve all” flow.

const needed = neededUsdcAllowance(collateralUsdc)
const { allowanceRaw } = await readUsdcAllowance(account)

if (!hasSufficientUsdcAllowance(allowanceRaw, collateralUsdc)) {
  await sendUsdcApprove(needed) // step 1 — wallet popup
}

await openMarketOrder(params)  // step 2 — atomic Veranta call

Next: Trust & Risk

0–100 algorithmic shield

Mentra Trust Score

Mentra Trust Score is a 0–100 algorithmic assessment of a Base project’s on-chain hygiene. It is stored intelligence — never a vibes overlay. The quant risk matrix folds LP lock duration, ownership renounce status, whale concentration, and contract upgradeability into a single shield used by project cards, share copy, and agent warnings.

Score inputs

• LP lock duration — longer, verifiable locks raise trust; unlocked liquidity is a penalty.
• Ownership renounce — ownerless or timelocked admin is healthier than an EOA with mint rights.
• Whale concentration — top-holder share and clustered funding wallets increase sybil / dump risk.
• Upgradeability — proxy admins and open implementation slots are scored as change-risk, not as a ban.

Pre-trade risk

On the trading path, Mentra adds liquidation proximity alerts and margin health calculators. For Veranta perps this is computed from mark (Pyth), position size, leverage, and maintenance margin — not from a guessed “safe” buffer. If mark is stale or Hermes is unavailable, the engine refuses to invent a price.

function trustBand(score: number): "high" | "mid" | "low" {
  if (score >= 85) return "high"
  if (score >= 60) return "mid"
  return "low"
}

// Project Intelligence Card uses stored trustScore 0–100.
// Share copy: "Mentra Trust Score: 93/100"

Next: Builder Identity

Composite 40 / 60

Builder reputation

Builder identity binds a Base wallet to a GitHub account (Privy OAuth). Mentra then scores the pair with a deterministic composite: 40% Code Velocity and 60% On-Chain Traction. Metrics are fetched — never invented. Missing GitHub or on-chain data simply zeros that component.

Composite scoring algorithm

• 40% Code Velocity — GitHub commit consistency (90d), active public repos, merged PRs via Privy-linked OAuth.
• 60% On-Chain Traction — contract deployments on Base, unique user interactions, processed volume (USD).
• Log-normalized so a single whale deploy does not dominate a consistent public builder.

export const WEIGHTS = {
  velocity: 0.4,
  traction: 0.6,
  velocityBreakdown: {
    commits90d: 0.5,
    activeRepos: 0.25,
    mergedPRs: 0.25,
  },
  tractionBreakdown: {
    deployments: 0.3,
    uniqueUsers: 0.4,
    volumeUsd: 0.3,
  },
} as const

const raw = velocityScore * 0.4 + tractionScore * 0.6
const score = Math.round(clamp(raw * 10, 0, 1000)) // 0–1000

Rank tiers & badges

Rank tiers are cut from that 0–1000 score: Top 1% Base Architect (≥900), Top 5% Ecosystem Builder (≥700), Active Base Developer otherwise. Dynamic social badges and the Intelligence Card share flow (X / Telegram / Warpcast) stamp rank + Mentra Trust without fabricating volume.

Next: Infrastructure

Pyth + RPC fallback

Real-time infrastructure

Execution quality depends on fresh marks. Mentra integrates Pyth Network Hermes for sub-second price updates and automated execution-fee quotes. The browser talks to a same-origin POST /api/pyth/latest proxy so PYTH_API_KEY never ships in the client bundle. Feed ids stay in the JSON body — not in multi-kilobyte GET query strings.

Pyth Hermes

• Hermes latest + stream for marks; VAA bytes (hex) feed Pyth updatePriceFeeds on Veranta opens.
• Server chunks Hermes at 40 ids; client POSTs up to 200 unique 32-byte feed ids.
• The Veranta trade adapter's getExecutionFee() is overlaid on the trade card so users see oracle cost before signing.

await fetch("/api/pyth/latest", {
  method: "POST",
  headers: { "content-type": "application/json" },
  body: JSON.stringify({
    ids: [
      "0xff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace", // ETH/USD
    ],
  }),
})

RPC fallback

Triple-layer fallback for reads: Base Mainnet RPC (primary, plus public Base endpoints) → DexScreener-style market metadata when a pair catalog is needed → internal cache (indexed positions, last-good marks). If every layer fails, Mentra surfaces an error — it does not hallucinate a last price.

Next: Security

Keys never leave the wallet

Non-custodial architecture

User funds remain 100% in user custody at all times. Mentra is a conversation layer and a transaction assembler. USDC, collateral, and vault shares sit in the connected address. There is no Mentra hot wallet, no deposit contract for “chat balance,” and no server-side signer.

Client-side signing

• Client-side transaction signing via Wagmi / Viem on Base (chain id 8453).
• Zero private key retention — no keys in localStorage, cookies, or API logs.
• Session (Privy / NextAuth) identifies the builder; it cannot move funds without a wallet popup.
• Allowances are per-spender and preferably exact-amount; revoke anytime from your wallet.

// Browser — unsigned call data only
const hash = await writeContract(wagmiConfig, {
  address: trading,
  abi: tradingAbi,
  functionName: "openTrade",
  args: [tradeTuple],
  value: executionFeeWei,
})

// Mentra servers never receive the private key.
// They may store public tx hashes after you broadcast.

Next: You are at the end of this hub.