aomiExecution Infrastructure for exchanges · frontends · trading platforms
Execution infrastructure · trading platforms

Every failed transaction is a fee you didn't earn.

Your users want limit orders, stops, and DCA — order types your venue doesn't ship, and each one a fill you'd earn a fee on. aomi runs them for you, as background agents trading from the user's own wallet. Every trade is rehearsed on a live copy of the chain before it is signed, so it lands or it never leaves. One integration, every chain.

Read the docs → Try the sandbox free to 1,000 monthly active users · no call required
73.4%
of bot transactions on Solana fail
ISSTA 2025 · 800M+ failed txs studied
86.4%
of those failures are slippage or stale state — exactly what pre-trade simulation catches
same study
$65M+
already paid to third-party frontends through Hyperliquid builder codes
Hyperliquid docs, 2026
40%
of Hyperliquid daily actives now trade through a third-party frontend
CoinGecko research, May 2026
00 The product, running

Every order goes out simulated,
or it doesn't go out.

Unedited screen captures. Routing, bridging, position rotation and scheduled execution — each stated in one sentence, each proven against live chain state before a signature exists. The last one keeps running after the tab closes: that is the order type your venue doesn't ship.

"Move most of my ETH over to Base — leave me enough on mainnet for gas." bridge · Across · keeps a gas buffer the user never specified · 2:20
"Now stake the rest with Marinade." swap settles, then a follow-up instruction in the same thread · Solana · 1:06
"Move my entire mSOL position over to JitoSOL." route Jupiter · price impact ~0% · simulation passed → staged for approval · 0:41
"Yes — do the whole sequence." Lido · Aave · erc20 · persisted as a recurring intent · 0:51
no audio · Solana and EVM · the venue never holds the key — the end user's wallet signs
01 Why this is worth building

Execution is a revenue line now.
The order types aren't there yet.

Builder codes settled the question of whether a venue will pay a frontend it didn't build: it will, per order, automatically, and it already has — at scale. What the venues don't ship is everything that happens between orders.

FrontendBuilder revenueUsersRevenue / user
Phantom$20,630,022137,496$150
Based$15,056,89442,579$354
PVP.trade$7,946,18528,189$282
MetaMask$6,510,54743,761$149
Insilico$3,306,8532,962$1,116
Hyperliquid builder-code earnings, HyperTracker snapshot via CoinGecko research (25 May 2026). Builder fees are capped at 10 bps perps / 100 bps spot and paid 100% to the builder. Comparable programs exist on dYdX (builder codes + order-router rev share), Extended (100% to builder, settled daily) and GMX (UI fee receiver).

The gap: perp venues give you spot and market orders. Limit, stop-loss, trailing, DCA, scheduled rebalancing and copy execution all have to run somewhere off the venue — continuously, per user, without holding their keys. That's the layer aomi is.

02 What it does

One pipeline. Every order lands or never leaves.

aomi runs its own full blockchain client, so it can spin up a private copy of any chain — a fork of live state — in ~200ms. Every trade goes through the same four steps: build it, rehearse it on that copy, have the user's own wallet sign it, broadcast it. Account abstraction and Solana Jito come built in.

Step 01

Build

Compose the exact transaction from an intent or a strategy — multi-step routes batched into a single operation.

intent → exact tx
Step 02

Simulate

Execute against a fresh fork of live chain state. Slippage, balances and the real output are known before anything is signed.

forked state · ~200ms
Step 03

Sign

Signed by the end user's own wallet under scoped, revocable delegation. Your platform never takes custody.

AA bundler · user's wallet
Step 04

Broadcast

Confirmed onchain with account abstraction and Solana Jito. No separate broadcast infrastructure to run.

AA + Solana Jito
Background order types

Limit, stop-loss, trailing stop, DCA, scheduled rebalancing and copy execution run server-side and keep working after the user closes the tab — each one a fill you charge a builder fee on.

Every surface, built once

The same execution layer serves your web frontend, Telegram, Discord and Slack from one runtime — no separate build per channel.

Multi-chain without the rebuild

EVM and SVM behind one interface. Adding a chain is configuration, not a quarter of engineering and a new broadcast path.

Per-call metering built in

Every tool call is priced and settled on-rails, so you can charge for what you ship — the same mechanism our launch partner Somm uses for app-level fees.

03 Where it fits — and where it doesn't

An honest latency budget.

Reasoning costs time. Simulation costs time. Both are free at some horizons and disqualifying at others, so here is the line rather than a claim you'd have to benchmark to disprove.

Sniping / MEV < 50 ms not a fit  Jito runs parallel auctions on 50ms ticks. A reasoning step cannot compete and we won't pretend otherwise.
Market making / HFT sub-second not a fit  Same reason. Keep your colocated stack.
Intent trading & swaps 2–10 s strong fit  Simulation is free at this horizon and prevents the failed fill.
Background order types seconds → minutes strong fit  Limit, stop, DCA, liquidation guards. Latency is irrelevant; correctness is everything.
Portfolio & treasury ops minutes → hours strong fit  Rebalancing, scheduled flows, multi-step position changes.

Also worth saying plainly: copy execution has a structural ceiling no infrastructure removes — the lead's own price impact lands before the follower does. We'll help you ship it and cap the damage with simulation and slippage bounds; we won't claim to make followers match leaders.

04 The architecture

The keys never move.
Which means a breach isn't a fund loss.

Most execution automation in this market runs on stored exchange API keys or a hosted burner wallet. Both concentrate the blast radius on your servers — and the industry has the incident history to prove it.

"Export Private Keys: Shows your Private Key to export for external use."

— a leading "non-custodial" Telegram trading bot, in its own documentation
A platform cannot show you a private key it does not possess. In 2022 a single bot platform leaked ~100,000 exchange API keys; the resulting class action was revived by the Ninth Circuit on 2 March 2026 and is live today.
Scoped delegation, not key storage

Execution runs under a revocable, permission-limited grant from the user's own wallet — Privy and Para compatible. aomi holds zero keys, and the runtime's counter says so.

Policy is enforced, not prompted

Value caps, allow-listed venues and per-wallet rules are checked outside the model. Published research shows prompt-based defenses fail against memory injection; ours isn't one.

Kill switch & instant revoke

Halt execution or revoke a grant immediately. A failed simulation or an out-of-policy order stops before signature, by construction.

Per-tenant isolation without per-tenant containers

One runtime serves all your users. No container per user — the line item that otherwise scales linearly against you as you grow.

Build
tool composes the exact tx
Simulate
prove the real outcome is safe
forked state · ~200ms
Sign
the user approves exact changes
AA bundler · user's wallet
Broadcast
confirmed onchain
AA + Solana Jito
🧑 🧑 🧑 ···· 🧑 User-specific
context
↕ ↕ ↕ ↕
Stateless Dispatch
Application
[app1, app2, ..].start()
Runtime
Scheduler.run()
🤖 🤖 🤖
Memory & IPC
Tool Scheduler
LLM Interface
evm-
gateway
db-driver
web-search
gpt5
Opus4.5
kimi-k2
Arb
Base
OP
Mainnet
solana
Forks Infrastructure
Full
Node
application-define forks ~200ms
Left, the pipeline every order passes through — one that fails simulation never reaches a signature. Right, the part your platform doesn't build: stateless dispatch fanning many users into one process, an agent thread per user, tool and model scheduling, and a fork of every chain served from a full node. One runtime, all your users — no container per tenant.
05 Pricing

Published, usage-based, and aligned with fills.

No seat licences, no demo gate, no annual minimum to start. Build against the sandbox today; pay when your users execute.

Sandbox
$0
Everything working end to end, against test state.
  • 1,000 monthly active users
  • All chains, all order types
  • Full simulation pipeline
  • No card, no call
Production
$10/mo
Per hosted runtime — not per user, not per container.
  • Unlimited end users per runtime
  • Background execution & scheduling
  • Every surface: web, Telegram, Discord, Slack
  • Per-app telemetry & tracing
Flow
10bps
On executed outcome value, settled onchain — the rail your own app fee rides too.
  • You price and keep your own app fee
  • Rates published in rates.toml
  • Volume terms above $10M/mo
  • Charged on settlement, not attempts
outcome_take_rate = 0.30 tool_take_rate = 0.10 managed_model_rate = 0.10 (waived with your own key) hosting_usd_month = 10.0
Every rate visible per application in your dashboard. Bring your own model key and the managed-model markup does not apply.
● live in production with Somm Finance ● app-level fees priced and settled on aomi rails ● x402 payment rail · onchain settlement
aomi

Ship the order types your venue doesn't.

Simulation before every signature, keys that never leave the user's wallet, one runtime across every chain and surface — and a fee line on every fill it lands.

Read the docs → Try the sandbox
aomi.dev · execution infrastructure for onchain trading