Search

Search benchmark pages, protocols, published runs and the docs

Rout
Partners · as of 2026-11-03

Benchmark your own flow

If you run launches or automated trades for your users, you can measure your execution with the same method and verifier, privately, before deciding anything. This page says what we built the benchmarks around, what is proven and what isn't, and how a test would be judged.Read the S0 protocol

Where Rout stands

Not on mainnet yet
Rout has not traded on mainnet. rout-next/src/domain/capabilities.ts:44-45 · rout-automation-ui@61469bf
Nothing measured
Every capability below is specified, not demonstrated. Each becomes a claim only when a benchmark turns it into a number you can recompute.
Available today
The method, the protocols, an independent verifier with tested statistics, and a no-keys shadow benchmark of your own execution.

What the benchmarks are built around

Problems where execution decides whether a launch or a position survives. Where Rout is only at parity, the row says so.
Launch-platform problems mapped to Rout capabilities
ProblemWhat it costsWhat Rout would doHow it's proven
Bundled creator buys miss the creation slotSnipers take the supply the bundle was meant to catch, and the launch has to be withdrawn
Would need Rout to carry a bundle you built and signed
Unverified
C · waits on engine answer E5
The guard reacts after outside buys, and its exit isn't guaranteed to landOutside flow keeps entering between the threshold and the exit
Flow-triggered exits with Rout/affiliate exclusion and a dedicated exit tip
Documented onlyParity, not an edge
STEP0 → A1 → A2
Landing speed is bought with fee spendTips and priority fees rise without a measured gain; failed attempts still cost
Exact tips as cost control; multi-route copies are table stakes
Documented onlyParity, not an edge
E0, then a partner-run variant
Buys sent with unlimited slippage, exits without price protectionFills far from the quoted price in fast markets
Explicit slippage on every order; bounded escalation on exits
Documented only
B (shortfall, after E9)
Auto-sell and counter-trade exits fail under volatilityPositions that should have closed stay open
Declarative sell rules, risk limits, firings taken back on forks
Documented only
B
A batch half-fails and users are told not to resendManual reconciliation; a blind resend can execute twice
Durable-nonce idempotency: at most one copy of an intent can land
Documented only
E0 double-landed = 0
The live data feed goes offlineReactive features act blind exactly when it matters
Missing or partial coverage becomes Unknown and rules fail closed; no client stream is offered
Documented only
E16 fault injection (not yet run)
Wallets get clustered and flaggedDetection undoes the point of the launch setup
A risk, not a feature: any integration must add no new signals. No Rout attribution on chain
Missing
Fingerprint review before any traffic; E10, E11

For most platforms the first concern isn't speed. It's that nothing new identifies their wallets, and that protection actually lands. The benchmarks put those first.

Start without keys or spend: a shadow benchmark

  1. Step 1You share

    Signatures and intent times for your guard, auto-sell and launch transactions, over a window you choose.

  2. Step 2rbench measures

    Landing within window, the Δslot tail, fail rate and cost on your own workload, partner-confidential.

  3. Step 3You keep

    A baseline any later test is compared against, and a verifier you can point at any vendor. Including us.

How the verifier worksThe protocols you'd agree

Ways to work together, and what each needs

Shadow measurement of your own executionAvailable now

You share signatures and intent times for your guard, auto-sell and launch transactions. rbench measures your landing, Δslot tail and fail rate on your own workload.

Needs
Nothing from Rout's engine. No keys, no spend.
Likely objection
“Why share our signatures?” Partner-confidential tier: nothing is published without your written consent, and you can run the verifier yourself.
The verifier, pointed at any vendorAvailable once licensed

Run rbench against any path you use today and get recomputable landing and cost numbers.

Needs
A licence decision on Rout's side.
Likely objection
“It's your tool, so it's biased.” Standard library only, cited methods, your RPC, your machine.
Pre-armed protective exitsWaits on engine work

You pre-sign durable-nonce exits (a full exit, an escalating-slippage ladder). Rout holds them and fires on a trigger, and never holds your keys.

Needs
Engine E12, E8, E10, E11; fingerprint review
Likely objection
“Pre-signed transactions in a third party's hands.” Each can land at most once (one nonce value), and if you hold the nonce authority you can invalidate them at any time by advancing the nonce.
Guard executorWaits on mainnet

Rout executes the protective response when outside flow crosses your threshold.

Needs
Mainnet, E1–E3, fingerprint review
Likely objection
“You run snipers; why trust you with our guard?” Data isolation in writing, separate infrastructure and keys, audit rights. And STEP0 first shows whether a faster guard is worth anything.
Auto-sell and counter-trade executorWaits on mainnet

Sell rules with bounded escalating slippage and their own tip.

Needs
Mainnet, E9, budget
Likely objection
“We already race several providers.” Multi-route sending is table stakes. What would differ is bounded slippage and idempotent resend, and only B can show whether that matters.
Submission layer onlyUnknown: E5

Rout carries transactions you build and sign, untouched apart from what you agree.

Needs
Engine answer E5
Likely objection
“Why not add another provider ourselves?” Possibly you should. E0 measures the path first, so you can decide on data.
Block-0 carrierUnknown: E5

Carry your creation bundle so the create and creator buys land in one slot.

Needs
Engine answer E5
Likely objection
“Bundle builders are commodity.” If E5 is no, this is removed from the offer and from this site.

Before any test traffic

All seven must hold. None is met yet: the first depends on Rout's mainnet record.
ConditionOwnerEvidence of doneState
P0Rout has a mainnet record (E0) and E1–E4 telemetry passes rbench.verify on a devnet runEngine teamA verified devnet run directoryOpen
P1The partner names the metrics it cares about and picks from A2, B and CPartner + RoutCall notesOpen
P2Protocol drafts finalized together; every open value agreed; hash posted by both sidesBothrbench.prereg check → ready_to_run: trueOpen
P3Written data isolation signedRout + partnerSigned documentOpen
P4Fingerprint review passed on POC wallets and pathsEngine team + partner0 new cluster signals in the partner's own toolingOpen
P5SOL budget approved per protocol (budget_lamports_max)RoutDecision noteOpen
P6The partner can run rbench on its own infrastructure and RPCPartnerTheir ./run_tests.sh passesOpen

How a test is judged

The criteria are fixed here; the thresholds are agreed with you and written into the protocol before the run. If a gate fails, the run is still published at its tier, failure included.
CriterionComputed fromPass rule
G1Lands more protective or exit transactions in timecomparisons[0].landed_within_window_differenceLower bound of the wider interval ≥ the agreed minimum difference
G2Not more expensive per successarms[].spend_lamports.per_landed_ok (ratio)≤ the agreed max cost ratio
G3No double executiondouble_landed_intents, double_landed_nonce_intents= 0, not negotiable
G4No worse execution quality (B only)Implementation shortfall difference≤ the agreed bps (after E9)
G5Undetectability preservedThe partner's own clustering tools0 new signals
G6Independently reproducedThe partner's metrics.json from its own RPCIdentical, or each difference explained and published
G7Complete denominator, honest assignmentintegrity_problemsEmpty

Boundaries

Your data stays yours
Rout runs snipers. If you run launches, your schedules, pre-creation mints, configurations and wallet lists never reach a Rout strategy host: separate infrastructure and keys, audit rights, in writing.
No new fingerprints
Durable-nonce accounts, fixed tip accounts and a shared call pattern can cluster wallets. The review runs with your own tools before any traffic, and nothing Rout-specific is added to your transactions.
No key transfer
The preferred shapes need none: you sign, Rout carries or holds. Any delegated signing needs its own security review.
Out of scope
Rout won't build features whose purpose is to evade retail-protection classifications (sniper or bundler share filters). The offer is landing, idempotency and exits.

What we can't promise yet

  • Any speed, landing-rate or cost advantage: nothing has been measured and Rout has no mainnet record.
  • That Rout can carry Block-0 bundles (engine question E5).
  • That an integration adds no fingerprints: the review hasn't run.
  • A data or trade stream: none exists.
  • Uptime or support levels: no SLO exists in any repository we can read.
  • Any price, trial or refund term.

What we'd ask you first

  1. Which outcomes matter most to you: guard response, Block-0 inclusion, exit reliability, cost?
  2. Which routes do you send through today, what landing rate do you see per route, and how many of your users turn multi-route sending on?
  3. What share of your trades go out on your own route rather than through a terminal's?
  4. How long does your guard take today, from the outside buy's slot to your exit landing?
  5. Would you accept pre-signed durable-nonce transactions held by a third party? How do you view nonce-account fingerprints?
  6. Does your fee transfer have to sit inside every trade transaction? Can a partner append instructions?
  7. Would you share signatures and intent times for a no-keys shadow benchmark?

Open questions on our side

Engine answers that decide which of the shapes above exist. All are open.
QuestionUnblocks
E0Has agentd ever sent on mainnet? Three signatures, or 'never'.Every execution claim
E1Append-only intents.jsonl per run: gap-free seq, verifiable armsEvery benchmark
E2attempts.jsonl: one row per signed copy, own signatureLanding, cost, route share
E3Probe mode: non-trading tx through the live path at scheduled slotsE0, the cheapest first Rout number
E4Chrony offset log and build sha on every runEngine ms spans
E5Can the engine carry a client-built tx or bundle?Block-0 (C) and the P1 pitch
E6Log pre-execution events that never land (false events)Any detection-lead claim
E7Publish tip accounts per providerVerifiable tips and spend
E8Anchor signature per trigger-based intentA1
E9One shared curve-price definition per venueB shortfall
E10Keep caller-chosen extra tip transfers in partner transactions, varying per walletIntegrations that must not look uniform on chain
E11No Rout memo, account or fixed tip account inside partner transactionsAny partner integration (no attribution)
E12Hold and fire partner-signed durable-nonce transactions, no partner keysPre-armed protective exits
E16Fault injection: feed gaps must fail closed (Unknown)Guard behaviour under feed loss