Docs

How it glides.

Short version: you open an order in a vault you own; an agent key slices it; the contract checks every slice.

How it works

  1. Plan. Type an order ("buy $500 NVDA over 2 hours") or pick token, size and window. The engine quotes the whole order against the live pool right now (Uniswap v3 for stock tokens and WETH, the Pons curve or Pons V4 pool for Pons coins) and reads Chainlink.
  2. Cut. It picks the number of slices so each fill stays under the impact target (30 bps by default), with a gap between slices so the pool can refill.
  3. Floor. For stock tokens and WETH the vault enforces Chainlink price ± your max slippage. Pons coins have no feed, so the vault enforces a limit price (minimum out per unit in).
  4. Run. Create your vault, deposit, open the order, set the Glisse agent as executor. The keeper executes a slice only when impact is under target and price is above the floor; otherwise it waits and writes why in the journal.
  5. Report. When the order fills, the engine compares your realised average price with the one-shot quote taken when the order opened. That number is measured, not modelled.

The "estimated saving" shown by the planner is an estimate: it quotes each slice against the pool as it is now, so it assumes the pool recovers between slices. If price trends against you or nobody refills the pool, the realised saving is lower or negative. Small orders on deep pools get an honest "one-shot is fine".

Limits the contract enforces

CheckWhere
Slice size ≤ sliceMaxIn and ≤ what is left of the orderexecuteSlice
At least minGapSec (≥ 60 s) since the last sliceexecuteSlice
Not after the order's deadlineexecuteSlice
Output ≥ max(agent's minOut, contract floor), else the swap revertsexecuteSlice
Stock and WETH floor = Chainlink price × (1 − maxSlipBps); maxSlipBps is 1–300 (max 3 %)openOrder, floorOut
Pool price must sit within maxSlipBps / 2 of Chainlink before a stock/WETH slice, in either directionexecuteSlice, poolCheck
Stale Chainlink feed (stocks > 2 h, USDG/WETH > ~24 h), paused stock oracle, or a stock split (> 1 % multiplier move) → no tradeexecuteSlice
Pons coins: limit price required (min out per 1e18 in); the owner can move it with setLimitopenOrder, setLimit
Only registry pairs (USDG vs WETH, NVDA, TSLA, SPY, AAPL) or ETH vs a real Pons V2 launchopenOrder

No proxy, no upgrade, no admin over vaults. The asset registry is fixed in the factory constructor.

What the agent key can and cannot do

  • Call executeSlice on an open order of a vault whose owner set it as executor.
  • Choose the slice size and minimum out, inside the limits above.
  • Withdraw, transfer or approve anything. Swap output always lands in your vault.
  • Open, change or cancel orders. Only the owner can.
  • Trade pairs outside the registry / Pons, or below the floor.
  • Act after you revoke it: setExecutor(0x0) pauses it at once.

The agent key lives on our server only. If it ever leaked, the worst case is slices executed within your own limits, never a transfer out.

Fees

No protocol fee. The vault's fee is fixed at zero in the deployed contract. Using Glisse costs gas plus the pool's own fee (Uniswap fee tier, Pons curve or hook fee).

Residual risk, plainly

  • Stolen agent key. It still cannot withdraw or transfer anything. The worst it can do is fill slices at your floor: for stocks and WETH at Chainlink × (1 − maxSlipBps), after pushing the pool up to maxSlipBps / 2; at most one slice per minGapSec.
  • Pons limits are static. The limit price stays where you set it until you call setLimit. If the coin rallies, slices can still fill at the old limit. Keep Pons limits close to market (≤ 3 % buffer) and deadlines short.
  • Orders do not escrow. Your vault balance is shared by your orders; a slice only runs if the balance is there.
  • Stale or paused feeds stop stock slices (quiet hours, weekends). The agent waits and says so in the journal.
  • Your exit is always one transaction: setExecutor(0x0) pauses the agent, withdraw takes funds out.

What is not audited

  • The contracts (GlisseFactory, GlisseVault) are tested (unit + mainnet fork) and reviewed internally, not audited by a third party.
  • The keeper, planner and impact heuristics are off-chain code. They can be wrong; the on-chain floor is the safety net.
  • The plain-English parser uses an LLM with a strict schema plus a regex fallback. Always read the plan before you sign.

Contract addresses and the Blockscout verification link are published here once deployed: not deployed yet.

API & MCP for agents

Public JSON API at https://glisseagent.xyz/api. Rate limited per IP.

POST /api/parse   {"text":"buy $500 NVDA over 2 hours"}
POST /api/plan    {"side":"buy","token":"NVDA","sizeUsd":500,"windowMin":120}
GET  /api/quote?token=NVDA&side=buy&amountUsd=500
GET  /api/assets
GET  /api/journal?limit=50&vault=0x…
GET  /api/orders?vault=0x…
GET  /api/stats
GET  /api/stream          (SSE: journal events)

MCP server (stdio, read-only): tools plan_order, quote, journal, stats.

{ "mcpServers": { "glisse": {
  "command": "node",
  "args": ["/path/to/glisse-mcp.js"],
  "env": { "GLISSE_API": "https://glisseagent.xyz" } } } }