Execution Algos

The Launcher (in the cockpit's console) carries the terminal's execution-algo catalogue. Every algo is a schema-driven form: parameters validate live as you type, and the same validation runs server-side again before anything is ever armed.

How arming works

Arming never moves funds through this site. A connected wallet signs in, then approves an order-only agent on Hyperliquid itself — it can place the orders you arm, never withdraw or transfer, and expires on its own — plus a builder-fee cap (0.04%, which no algo's rate exceeds). Both approvals are prompts your wallet shows you and are revocable at any time. From there, Arm posts your params to the server, the server re-validates them against the same schema the form was generated from, and the worker engine works the order on Hyperliquid signed by your agent. Per-account size caps apply during early launch and are stated on the ticket when they bind.

Armable algos also carry a close current position toggle: in close mode the engine sizes from what you actually hold (never more), every child order is reduce-only, and the position can only shrink.

Available now (preview + on-chart schedule + cost pre-flight)

Coming later (visible, honestly greyed)

Algos that need infrastructure not yet live are shown greyed with the reason and the phase that unlocks them — never hidden:

• VWAP — slices sized to the coin's intraday volume curve (needs weeks of stored volume history).
• POV (Participation) — target a percentage of live traded volume, never exceed the cap.
• Arrival Price (IS) — an Almgren–Chriss optimal schedule with an urgency dial; impact parameters calibrate from our own fill journal.
• SnapBack — execution that breathes with the statistics: per-slice aggression modulated by the live z-score.
• Corridor — a resting ladder placed in σ-space rather than price-space, re-anchored at each daily refit.
• PairGlide-Z — PairGlide with a z-modulated schedule: DCA in σ-space.

Algo by algo

Every algo in the Launcher carries a full Playbook panel in the console — eleven sections, from field-by-field setup rationale to a quant corner — rendered from the same schema that validates the form. The subsections below are the condensed, hand-synced versions.

Adaptive Market

What it does — part maker, part taker: the order decides which, live. It starts passive at the near touch (join or improve one tick, post-only), then walks the spread — while it is getting filled it sits, meaningful fill flow resetting the rung timer; while it is missing it escalates a tick at a time, faster when the far touch is running away. The terminal rung crosses IOC inside your slippage cap, so the market flavour always finishes. Urgency sets the rung dwell — patient 8s, normal 3s, fast 1s, calibrated in the engine's simulator: normal is the cost sweet spot on a busy tape, fast finishes sooner for a few bps more, patient costs time, not money.

Status — live: armable by any connected wallet that has enabled trading. Arm posts your params to the create endpoint, the server re-validates them against the same schema the form was generated from, and the worker engine walks the book for real — one child order, re-pegged by the venue's modify action, until filled or crossed at the cap. Restart-safe by client order id. Venue order minimum: $10. A long-lived walk can be paused by the desk's safety watchdog — the resting order stays on the venue book and fills keep landing; a resumed walk picks up exactly where the venue says it is.

Reach for it when you were about to press Now (IOC) and the spread is more than a tick wide — same completion guarantee, with a real chance of paying less than the full spread. Skip it when the spread is one tick (nothing to walk — IOC gets there sooner) or when you care about a session average, not this fill (that is TWAP+'s job).

Watching & fills — the current rung reads as a distance from the touch. Sitting at rung zero is the good state: the book is coming to you at maker prices. Fill texture is mixed by design — maker prints while sitting, possibly one taker print at the end.

Stopping & asleep — no pause: the walk lives on a seconds-to-minutes clock, so cancel and re-arm is the honest restart. Cancel pulls the resting child immediately; what filled is yours.

Costs — fees follow the fills: maker while sitting, taker only on the terminal cross. Each rung is one modify, about one venue action — cheap on the rate budget. Builder fee: 1 bp per fill.

Worst day — a running market: escalation chases the far touch and the walk ends at the cap — roughly what IOC would have charged at the start, plus the time it took to find out. The cap held; the walk cost time, not money beyond it.

Quant corner — expected cost interpolates between post-only at the touch (cheapest, may never fill) and IOC (dearest, fills now); the walk is a stopping rule on that line. Modeled on IBKR's Adaptive Algo, documented to beat plain market/limit on average because most spreads are wider than a tick.

Now (IOC)

What it does — one atomic taker cross: an immediate-or-cancel limit priced at your slippage cap from mid. Whatever fills inside the cap fills now; the remainder cancels in the same instant. A worse fill is rejected, never taken.

Status — live: armable by any connected wallet that has enabled trading. Arm posts your params to the create endpoint, the server re-validates them against the same schema the form was generated from, and the worker engine prices the cap off the live mid and sends one immediate-or-cancel child — the parent is finished in the same second: filled, partially filled with the shortfall named, or rejected honestly. A crash between send and settle is resolved by client order id against venue truth — a taker order is never blindly resent. Venue order minimum: $10.

Reach for it when you want the position now and the pre-flight says one clip clears inside your cap. Skip it when your ticket is more than a few percent of the visible book — you are the market; a slicer or Iceberg spends your patience properly.

Watching & fills — nothing to babysit: the result lands before the blotter can show it working. One fill event, possibly partial — a partial means the cap held and the remainder was cancelled rather than chased.

Stopping & asleep — nothing to cancel; the venue cancels the remainder in the same instant it fills. No asleep concept: it is instant.

Costs — pure taker: fee plus the walk up the book, both priced by the pre-flight before you touch anything. One print, no fingerprint, no rate budget to speak of. Builder fee: none — a bare hit routes builder-free.

Worst day — a rejection, and it is deliberate. The worse failure is the one this order refuses to commit: filling you at any price.

Quant corner — expected cost = half-spread + taker fee + impact from the level walk, bounded at cap + fee by construction. All impact, zero timing risk — every other algo on this desk exists to move away from this corner.

TWAP (native)

What it does — hands the parent to the venue's own TWAP: taker sub-fills every 30 seconds, each capped at 3% slippage, for 5 minutes to 24 hours. Once placed, our stack is out of the loop entirely.

Status — live: armable by any connected wallet that has enabled trading. The ticket posts your params to the create endpoint, the server re-validates them against the same schema the form was generated from, and the worker engine hands the parent to the venue.

Reach for it for set-and-forget with the strongest uptime story available, and when you want nothing to mistune. Skip it if you want maker fills, pause/resume, jitter, a tighter per-slice cap, or more than 24 hours — none of those exist here.

Watching & fills — sub-fills print every 30 seconds like clockwork; the venue accepts no edits, only a cancel. The engine polls the venue's fill tally, journals progress, and raises a lag alert when fills fall behind the clock. The average converges on the interval TWAP by brute regularity.

Stopping & asleep — cancel kills the remainder exchange-side in one action. The order lives on the exchange and keeps running even if our entire stack dies.

Costs — every sub-fill pays taker; rate budget is near zero. The real cost is the fingerprint: a 30-second metronome at constant size is the most readable flow on this desk. Builder fee: none — venue-native, routed builder-free.

Worst day — thin books: the 3% per-sub-fill cap can leave sub-fills partial and the parent quietly under-fills. Check the tally against the clock, not just the clock.

Quant corner — this is the benchmark TWAP+ has to beat: identical schedule shape, taker every time. When TWAP+'s "maker saves" line is small, this order's simplicity wins.

TWAP+

What it does — slices the parent evenly across a set duration, resting each child maker-first (ALO) and crossing only when the schedule slips. Slice timing and size are jittered so the flow does not print a recognizable pattern.

Status — live: armable by any connected wallet that has enabled trading. Arm posts your params to the create endpoint, the server re-validates them against the same schema the form was generated from, and the worker engine slices server-side — every child is its own client order id, placed and cancelled, never modified. Restart-safe; the slice clock re-anchors after any pause or deploy, so the parent finishes later, never compresses. The venue's $10 order minimum applies per child — the form enforces notional ÷ slices ≥ $10.

Reach for it when you want an average price over hours and the pre-flight's "maker saves" line is meaningful at your size. Skip it if you need the position now, or the book is so thin even sliced children move it — Iceberg is the honest tool there.

Watching & fills — the blotter shows filled versus total and the countdown to the next slice. "Behind schedule" means passive children are not filling and the engine is preparing to cross — expected in a trend; worth a look if it persists. Fills tick like a metronome, jitter aside.

Stopping & asleep — pause is engine-side today (the desk's safety watchdog or an operator): it pulls the resting child and freezes the clock; resume re-anchors, and the parent never compresses to catch up. Cancel pulls every resting child immediately — what filled is yours. The parent lives in the engine: restart-safe by client order id, with a venue-side dead-man switch that auto-cancels children if the engine ever goes silent.

Costs — maker-first is the cost thesis: each passive fill earns the maker rate instead of paying taker plus impact. Roughly three venue actions per child; the pre-flight verdicts the rate budget before you commit to an interval. Builder fee: 1.5 bp per fill.

Worst day — passive non-fill in a trend: the schedule slips and the fallback pays up to the slice cap, repeatedly. That is the algo working as designed — the cap decides what you pay to stay on schedule.

Quant corner — linear schedule x(t) = N·t/D; jitter draws each child's time and size from independent ±j% bands. TWAP is the flat-urgency special case — the machinery where urgency is a dial arrives with Arrival (IS).

Multi-day TWAP

What it does — TWAP+ stretched past the venue's horizon: a database-backed parent that slices for weeks and survives worker restarts and deploys. The parent lives in the engine — the venue only ever sees the children. Optional funding-aware leaning turns the schedule's slack into a fee edge.

Reach for it when your size needs weeks and you want to check in daily, not babysit — needing more than one blotter glance is a design failure, ours not yours. Skip it if the job fits inside a week; plain TWAP+ does it with less machinery.

Watching & fills — one blotter row: filled versus total, days elapsed. The daily check is fill-versus-schedule. Metronome texture stretched over weeks — single loud days matter less the longer the horizon, which is precisely what you are buying.

Stopping & asleep — pause and resume as TWAP+; even a multi-day pause pushes the finish out. This is the algo the restart guarantee was built for: the parent resumes from the database by client order id and never doubles a child.

Costs — a small per-fill maker save times hundreds of children is the whole thesis; funding-aware leaning adds a second, quieter edge on the same schedule. Builder fee: 2 bp per fill.

Worst day — drift, the honest one: over weeks the market can walk away from your arrival price, and no execution algo insures that. Timing risk is the risk you chose when you chose the horizon.

Quant corner — same linear machinery with the duration in days. Funding-aware is a soft tilt within each slice's slack, never a reschedule. Restart is a reconciliation lookup against deterministic order ids — never a guess.

Iceberg

What it does — rests a visible sliver at your price and hides the rest of the parent. Each time the display fills, a fresh randomized sliver replaces it.

Reach for it when your ticket is a large fraction of the visible book and you have a price and patience — you are supplying liquidity and getting paid the maker rate to wait. Skip it if you need certainty of completion: this may never finish, by design.

Watching & fills — the thing to watch is stillness, not motion: a display that never fills means price has walked away from your level. Fills are lumpy and passive, all maker; a partially-complete parent is the normal end state to plan around, not an error.

Stopping & asleep — cancel pulls the current display and abandons the hidden remainder, which never touched the venue. Engine-side: restart-safe, dead-man protected.

Costs — all maker, no impact; the real cost is time and the risk of never completing. Display size is randomized because a display refreshing at one constant size is a beacon — anyone can sum your slivers into your parent. Builder fee: 0.7 bp per fill.

Worst day — adverse selection: your display fills fastest exactly when the market is coming through your level. The fills you get most easily are the ones you will most regret at the close.

Quant corner — fill arrival is a queue problem; the limit offset moves you along the fill-probability-versus-price curve. The maker rebate is the market's payment for adverse selection — compensation, not free money.

Status — live: armable by any connected wallet that has enabled trading. Arm posts your params to the create endpoint, the server re-validates them against the same schema the form was generated from, and the worker engine rests one visible sliver add-liquidity-only at your level — the touch at arrival backed off by your offset, fixed for the parent's life — and re-arms a fresh randomized sliver there each time the display fills. The level never follows the market (that is Chase's job), every fill is maker, and the hidden remainder never touches the venue. Restart-safe by client order id; the resting sliver sits under the dead-man switch. Venue order minimum: $10 — it binds each sliver, which is why the display floor is $10 too.

Chase

What it does — rests your full order post-only at the touch and re-pegs it by modify every time the touch moves. Always at the best price, always maker, never crossing — until the optional give-up timer says cross now.

Reach for it when you want in, refuse to pay the spread, and can tolerate not knowing when you fill — the re-peg loop survives the tab because it never lived in the tab. Skip it when the tape is trending hard away: a chased touch in a runner is a treadmill.

Watching & fills — the number worth watching is chase distance: a touch that keeps stepping away means every re-peg is the market repricing without you. Fills are feast or famine, all maker; if the give-up fires, the tail is a single taker IOC.

Stopping & asleep — cancel pulls the resting order in one action. The dead-man switch matters more here than anywhere: a chase whose engine went silent is a stale limit pretending to be at the touch.

Costs — maker the whole way; the economics are the spread you refuse to pay, collected as a rebate. Rate budget is re-peg-driven — volatility sets the modify count, so no honest fixed number exists. Builder fee: 1 bp per fill.

Worst day — the treadmill: a trending market re-pegs you forever and fills you never (give-up 0 can chase all week — that is the discipline you asked for). And the adverse give-up fill: the IOC crosses at the worst moment by construction — budget for that price when you set the timer.

Quant corner — a chase is pure adverse-selection flow, compensated by spread plus rebate; each re-peg re-prices that option at the new touch for free. The give-up flips (maker price, unbounded time) into (trend price plus taker fee, now).

Status — live: armable by any connected wallet that has enabled trading. Arm posts your params to the create endpoint, the server re-validates them against the same schema the form was generated from, and the worker engine chases server-side — one child order pinned to the touch, re-pegged by the venue's modify action, never escalating and never crossing on its own. The give-up cross, if set, prices its cap from the mid at the moment it fires — the market you gave up in, not the one you started in. Restart-safe by client order id, give-up clock included. Venue order minimum: $10.

Scale / Ladder

What it does — lays a ladder of resting limits between a near and a far edge from mid, sized flat or weighted toward the far rungs, re-arming any rung the venue lets go of unfilled. A standing offer to fade the move at prices you chose in advance — never past your total.

Reach for it for range accumulation — you believe in a zone, not a price — or to fade a move with conviction expressed as geometry. Skip it in a breakout tape: the ladder fills rung by rung into the move, every fill against the direction that just paid everyone else.

Watching & fills — "show on chart" draws the ladder against the candles, the honest way to see whether your zone and the market's agree. A ladder untouched for days is information, not malfunction. Fills come in bursts as price probes the zone; a rung that fills partway keeps resting for the rest of its slice, so one level can pay you several times on the way to spending its allocation. All maker.

Stopping & asleep — cancel pulls every resting rung at once: one action, the whole ladder gone. Engine-side: restart-safe, dead-man protected.

Costs — all maker, and a chop that spends a level in pieces pays the rebate on every piece. Rate budget is levels times churn. Fingerprint mitigation is coarser than jitter: fewer, larger rungs are quieter than many small ones — the opposite of the usual instinct. Builder fee: 0.7 bp per fill.

Worst day — the one-way tape: a real break fills the whole ladder on its way through — biggest rungs last, if far-weighted — leaving you maximum size at the exact moment the range thesis died. The far edge is your pre-committed answer to "how wrong before I stop adding".

Quant corner — a static market-making book with no requote: its edge is rebate plus mean-reversion capture inside the range. The payoff is short-volatility in shape — fill quality is best when the range assumption bends and worst when it breaks.

Status — live: armable by any connected wallet that has enabled trading. Arm posts your params to the create endpoint, the server re-validates them against the same schema the form was generated from, and the worker engine rests every rung at once, add-liquidity-only, at fixed levels interpolated near→far from the arrival mid — rounded away from the market on the venue grid, never nearer than you asked. Each rung owns its slice of the parent for the parent's life: a filled rung is spent, so the total is exact by construction, while any rung the venue releases unfilled re-arms at its level with its remainder. The levels never follow the market (that is Chase's job) and every fill is maker. Restart-safe by client order id; the resting ladder sits under the dead-man switch. Venue order minimum: $10 — it binds each rung, which is why the form checks the smallest rung against it.

Stop / Take (native)

What it does — stages a trigger order on the venue: when price crosses your trigger, the exchange fires it. Stop mode fires through the level as a market order, bounded by a fire-time cap — certainty of exit; take mode fires on the favorable side and rests a limit at your trigger — certainty of price, and a gap can leave it unfilled. Either way it lives exchange-side from the moment it is staged — our stack can die and your stop still stands.

Status — live: armable by any connected wallet that has enabled trading. Arm posts your params to the create endpoint, the server re-validates them against the same schema the form was generated from, and the worker engine resolves the trigger level off the live mid — mid plus your offset, snapped to the venue grid, shown resolved in the blotter — and stages one venue trigger order. From then on the exchange watches the price, not us: it fires on the venue's own mark price (per Hyperliquid's docs), even while the terminal is offline. The parent may honestly rest for weeks; cancel un-stages it by client order id in one action. If an account-wide cancel-all (another algo's dead-man switch, a manual sweep) takes the staged trigger with it, the engine re-stages it at the same level and alerts you — with the honest admission that a gap window existed while it was down. The fill is scored against the trigger itself, not arrival — trigger slippage is this order's honest number. Venue order minimum: $10.

Reach for it for protection that must not depend on anyone's uptime, ours included, or to pre-commit an exit or breakout entry decided calmly now. Skip it if you expect a fill near the trigger price through a gap — a stop guarantees firing, never price (take mode is the mirror: price, never a fill).

Watching & fills — nothing works until it fires; the one check that matters is drift, whether mid has walked far enough that your offset no longer means what you meant when you staged it. Stop mode: one market fill at whatever the book holds in that instant, bounded by the fire-time cap. Take mode: a limit resting at your price once fired — it can fill at your price, partially, or not at all.

Stopping & asleep — cancel un-stages the trigger venue-side; nothing to unwind because nothing was working. Alongside native TWAP, the strongest asleep answer on the desk — the engine's own dead-man switch is deliberately not armed here, because auto-cancelling a protective stop when we go quiet would be the opposite of protection.

Costs — stop mode pays taker at fire, plus the distance between trigger and fill: the true cost of a stop is paid in the fill price, not the fee line. Take mode can fill as maker at your price. A staged trigger does not sit in the visible book. Builder fee: none — venue-native, routed builder-free.

Worst day — gap risk, plainly: a gap through your trigger fills where the market is, not where you drew the line — a 100 bps offset can fill 500 bps away in a violent print. And wick fires: a one-print spike through the trigger fires it; the venue does not wait to see whether the move was real.

Quant corner — a stop is a knock-in market order you have written to the tape. "Trigger hit" and "book thin" are correlated by construction, which is why stop slippage runs worse than average slippage. Size against expected at-trigger depth, not current depth.

Bracket (TP + SL)

What it does — take-profit and stop-loss on your open position, in one ticket. Two venue trigger orders are staged exchange-side, tied to the position itself: the stop leg sits on the losing side and fires through the level as a bounded market order; the take leg sits on the winning side and fires as a limit at your price. One leg firing the position flat cancels the other — the OCO lives on the exchange, not in our stack. Close-only by design: both legs are reduce-only and sized by the venue to whatever the position is when a leg fires.

Status — live: armable by any connected wallet that has enabled trading, with the close current position toggle — entry-side arms are refused, because there is nothing an entry-side bracket could honestly mean. Arm posts your two offsets to the create endpoint, the server re-validates them against the same schema the form was generated from, and the worker engine resolves both levels off the live mid — snapped to the venue grid, shown resolved in the blotter — and stages two position-tied venue triggers. From then on the exchange watches the price, not us: either leg fires on the venue's own mark price (per Hyperliquid's docs), even while the terminal is offline, and firing the position flat cancels the sibling server-side. Close the position some other way and the venue stands the bracket down with it — stated plainly, never re-staged. A leg swept unfired by an account-wide cancel-all while the position still stands is re-staged at the same level with an alert naming the gap window; repeated sweeps give up loudly with the survivor un-staged — half a bracket is not protection. The fill is scored against the fired leg's own trigger. Venue order minimum: $10 (full closes exempt).

Reach for it when you hold a position and want both exits standing — target and protection — without depending on anyone's uptime, ours included. Skip it if you are flat (the Stop / Take desk covers entry-side triggers), or if you expect a fill near the stop price through a gap — the stop leg guarantees firing, never price; the take leg is the mirror.

Stopping & asleep — cancel un-stages both legs venue-side; the engine's own dead-man switch is deliberately not armed, because auto-cancelling a protective bracket when we go quiet would be the opposite of protection. Alongside Stop / Take and native TWAP, the strongest asleep answer on the desk.

Worst day — the stop leg's gap risk (fills where the market is, not where you drew the line, bounded by the fire-time cap) and the take leg's mirror (the gap fires it and keeps going — your limit rests at the price the market just left, honestly unfilled).

Quant corner — a bracket is a knock-out structure written on your own position: the two legs' worst days are anti-correlated by construction — that is the point of holding both. Offset geometry is the whole decision: stop distance trades false fires against realized loss before firing; take distance trades fill probability against profit per fill.

VWAP (greyed)

What it does — slices the parent to the coin's own intraday volume curve: bigger children when the market usually trades big, smaller when it thins — targeting the session's volume-weighted average price instead of the clock's.

Reach for it when you are judged against the whale-standard benchmark, or the coin has a strong intraday rhythm. Skip it if the coin trades flat around the clock — then VWAP degenerates to TWAP and the extra machinery buys nothing.

Why it waits — greyed until weeks of stored volume history exist to fit the curve from. A VWAP without a real curve is a TWAP wearing a costume.

Worst day — the curve is an estimate of habit, and news breaks habits: a curve fitted on quiet weeks misallocates a loud day, leaning size into hours that no longer matter.

Quant corner — children sized proportional to the fitted intraday profile, with shrinkage toward uniform so thin history cannot generate a wild schedule. The benchmark is self-referential at size — your own children are in the tape you are measured against, the classic reason VWAP flatters large orders.

POV (Participation) (greyed)

What it does — ties your participation to the tape: the engine watches live traded volume and keeps your fills at or under a target percentage of it. The market sets the pace; you set the share.

Reach for it for mandate-style flow — "be no more than x% of the volume" as a hard promise. Skip it if you need a completion time: runtime is unknown by design, and very thin coins barely let it work at all.

Watching & fills — a participation gauge against the cap is the whole dashboard. Stalls mirror the tape: when volume dies, the order goes quiet with it — obedient, not broken. Duration is an output, never an input.

Worst day — the stall, by contract: the cap that protects your footprint is the same ceiling on your catch-up. And printed volume is not always real volume — a wash-traded burst reads as tape and leans your participation into it; the cap bounds the damage but does not detect the game.

Quant corner — filled(t) ≤ p·V(t) on a rolling window; expected runtime N/(p·v̄), unknown because v̄ is. Your share of the tape is the first-order driver of your footprint — which is why mandates are written in participation terms in the first place.

Arrival Price (IS) (greyed)

What it does — Almgren–Chriss with one dial: hurrying costs impact, waiting costs variance, and the urgency setting picks your point on that curve. The engine solves for the schedule minimizing expected cost plus your aversion to timing risk, benchmarked to the price at arrival.

Reach for it when you can say which you fear more — a worse average from pushing, or drift while you wait — and want that answer turned directly into the schedule. Skip it if you already know the shape you want (even slices is TWAP+, the tape's rhythm is VWAP), or on cold-start coins: impact parameters calibrate from our own fill journal, and no journal means no calibration.

Watching & fills — the planned curve front-loads relative to TWAP's straight line, spending early while remaining inventory — and therefore variance exposure — is largest. Behind-plan reads the same as TWAP+.

Worst day — garbage in: a thin fill journal means wide error bars, and the "optimal" schedule inherits them silently. A σ fitted on last month prices timing risk for a market that no longer exists.

Quant corner — minimize E[cost] + λ·Var[cost]: remaining inventory decays exponentially at a rate ∝ √(λσ²/η). TWAP is the λ→0 limit, the manual ticket is λ→∞ — every algo on this desk lives somewhere on this one curve; IS lets you pick the point explicitly.

SnapBack (greyed)

What it does — execution that breathes with the statistics: per-slice aggression scales with the live z-score of the spread. Stretched, it presses; at the mean, it idles. The schedule serves the signal, not the clock.

Reach for it for statarb entries where "when" matters more than "how fast". Skip it with no view on the spread — a z-modulated schedule without a signal edge is noise-chasing with extra steps — or when you need completion by a time.

Watching & fills — the z chart and the slice sizing should agree: idle at the mean is correct behaviour, not a stall. Bursty by the clock, regular by z — judged against z it is the most regular flow on the desk.

Worst day — signal-driven is not signal-guaranteed: a z that keeps widening fills you into what turns out to be a regime change, not noise. Pressing into a break is this algo's worst day.

Quant corner — a monotone size multiplier in |z| with sign gating: it only presses the reverting side. The operating truth is the band around the estimate, not the point — an execution model that trusts a point z is one refit from wrong.

Corridor (greyed)

What it does — a resting ladder placed in σ-space instead of price-space: rungs at fixed z-distances from the fitted mean, re-anchored daily when the pair refits. Getting paid to wait, measured in the spread's own units.

Reach for it when you would run Scale on a spread but know the right grid is statistical, not visual — σ-anchored rungs stay meaningful as vol changes; price rungs quietly stop meaning anything. Skip it on trending or broken spreads: a corridor in a regime change is a ladder into a knife.

Watching & fills — the event worth reading is the re-anchor: after a violent day the refit can move the ladder materially — the ladder you staged is not always the ladder you woke up to. Maker fills at statistically stretched prices, in bursts.

Worst day — the reversion book's tail: fills concentrate right before breaks. A corridor that suddenly fills all its far rungs is not succeeding — it is warning you.

Quant corner — rung price = μ̂ + zᵢ·σ̂ from the daily refit. σ-anchoring versus price-anchoring is the whole argument: z rungs are stationary in the model's frame, and the corridor is a bet that the frame holds.

PairGlide (live)

What it does — two legs, one order: β-weighted clips work both books at once, held inside the fill-balance band. One clip is a matched pair of children sized by the hedge ratio — the parent is a spread trade, never two independent tickets.

Status — live: armable from the pair ticket by any connected wallet that has enabled trading. Arm posts your params and the pair's id to the create endpoint; the server resolves the recipe itself — locked if you're in a position on the pair, today's plan otherwise — and re-validates the hedge ratio against the [0.4, 2.5] balance band before anything is written. The worker engine then works β-weighted IOC clips on both books in lockstep. Nothing ever rests on either book: a resting single leg would BE the naked position, so every clip is a capped IOC and a dead worker leaves fills behind, never open orders. Restart-safe — the two-leg ledger rebuilds from the journal's arrival prices, and a resumed schedule finishes later, never compresses. The venue's $10 order minimum applies per clip, per leg.

Exit mode — armed exits on Book positions fire this same engine. Every exit clip is reduce-only, so the position can only shrink; sizing comes per leg from what you actually hold — the smaller of your journaled entry fills and the venue's own position, never more — and the schedule auto-shortens so no clip lands under the venue minimum. Exits are never blocked by the notional caps, because closing reduces risk. The exit ticket's “also flatten the extra” option additionally squares any venue-vs-journal residual at the close.

Reach for it to enter or exit a pair position at size, where legging in by hand is itself the risk. Skip it on one-leg conviction: a pair algo will keep buying the other side on you, because that is its job.

Watching & fills — fill balance is THE gauge: inside the [0.4, 2.5] band the engine glides; at the edge it stops adding to the heavy leg and works only the light one. Two ledgers, one parent: per-leg averages plus the combined spread price you actually achieved.

Worst day — the naked leg, this algo's core warning: a filled leg without its partner is a directional position you did not order. The band bounds how naked you can get; the stop-adding rule is the enforcement. When one book empties, the band pins the whole order to the thin leg's pace — slower is the correct outcome.

Quant corner — leg-B notional = β × leg-A notional from the current hedge ratio. The band is deliberately wide: balance is a constraint to be respected, not an error to be minimized — exact-balance chasing pays real fees to cancel statistical noise.

Autospreader (live)

What it does — the classic spreader grammar on our pairs: rest a quote on the illiquid leg at your target z; the moment it fills, hedge the liquid leg IOC. Earn the maker side where the spread is wide, pay the taker side where it is cheap.

Status — live: armable from the pair ticket by any connected wallet that has enabled trading. Arm posts your params and the pair's id to the create endpoint; the server resolves the recipe itself — locked if you're in a position on the pair, today's plan otherwise, including the spread mean and volatility the quote prices from — and re-validates the hedge ratio against the [0.4, 2.5] balance band before anything is written. The worker engine rests ONE maker quote at the price implying your target z (one client order id across every re-peg), hedges IOC on each fill inside the give-up cap, and stands down honestly when it cannot. Because the quote RESTS, this engine runs under the dead-man switch for real: a silent worker means the exchange cancels the quote on its own. Restart-safe — a redeploy picks the resting quote back up without re-placing it.

Reach for it on pairs with one thin leg — quoting the thin side is where the edge lives, and the machine's hedge reflex is what makes quoting it survivable. Skip it when both legs are deep and tight, or when the hedge book carries real slippage risk: a fragile hedge book poisons the whole economics.

Watching & fills — hedge quality per event: the gap between quote fill and hedge completion, in time and in price. Rising hedge slippage is this algo's early warning. Fills land as paired events — maker on the quoted leg, taker on the hedge — shown as one spread fill, not two coincidences.

Worst day — legging risk in a fast tape: the hedge IOC can partially fill, and the window between quote fill and hedge completion is exactly the position you did not want — short by design, never zero. When hedging repeatedly costs more than the quoted edge captures, the algo stands down rather than grinding a negative spread.

Quant corner — edge per round trip ≈ maker rebate + captured spread − expected hedge cost. It quotes the wider-spread leg by default: the spread you capture is the wide one, the spread you pay is the tight one.

PairGlide-Z (greyed)

What it does — PairGlide with the schedule bent by z: DCA in σ-space. Clips accelerate when the spread is stretched in your favour and ease off at the mean — the same married-legs machinery, running on a signal-shaped clock.

Reach for it to build a pair position over days where entry quality in σ matters more than entry time. Skip it for deadline-driven entries: a z-modulated schedule owes you nothing by any particular date.

Why it waits — this ships only after PairGlide is boring and proven. That is a design statement, not a delay excuse.

Worst day — everything PairGlide can do wrong plus everything SnapBack can, and they compound: a regime break both stretches z (inviting size) and drains one leg's book (straining the band) at the same time. The band holds; the thesis is your problem.

Quant corner — clip rate r(t) = r₀·m(z), with the same modulation family as SnapBack applied to PairGlide's β-weighted clip stream. The balance band is unchanged — modulation changes tempo, never the marriage.

On-chart preview

"Show on chart" draws the configured schedule directly on the cockpit chart: slice dots stepping into the future for time-sliced algos (down-sampled honestly — the caption says "every Nth" when there are too many to draw), price lines for ladder rungs and triggers, colored by side. The preview clears when you switch coins.

Cost pre-flight

Before arming anything, the Launcher prices the plan using the same live book the depth panel walks:

• Per-child costs — taker all-in (fee + impact) per slice, the maker-rest alternative, and the estimated bps saved per fill by resting.
• Builder fee — the selected algo's own rate from the schedule below, included in every estimate; free algos add nothing.
• Native baseline — TWAP variants are compared against the venue's native TWAP so the value of the custom slicer is a number, not a claim. The baseline is priced builder-free — that is what it actually costs through us.
• Rate budget — a verdict on whether the schedule fits within API rate limits.
• HIP-3 fees — deployer fee multipliers are detected per market and included.

If a slice would exceed the visible book, the pre-flight says so instead of extrapolating.

Builder fee — our per-algo schedule

Our fee is cost-based and priced per algo: native venue features and a bare market hit are free; the more modelling and monitoring an algo needs, the more it costs. Pair algos charge per leg, per fill — a pair order is two order streams, and each leg's notional pays its rate.

Every rate is capped by the single 0.04% approveBuilderFee your wallet signs once — no algo exceeds it — and the approval is revocable on Hyperliquid at any time. The pre-flight shows the selected algo's rate before you arm anything, and every all-in estimate already includes it.

Published fill quality

The engines mark their own homework in public. Every parent order that runs on mainnet journals a benchmark before it finishes — the arrival price at launch and the side-signed slippage against it — and the fill-quality page renders that journal whole: done, cancelled and failed orders alike, entries and exits, per-algo distributions plus a row for every single parent. Nothing is filtered or cherry-picked; while the mainnet sample is young the page says so plainly rather than dressing it up. Positive bps means the fill cost that much vs arrival; negative means it beat arrival. Pair orders report both legs combined, weighted by filled notional.

Click-to-price

Clicking a level in the Liquidity Terrain (or its 2D fallback) sends that price to the Launcher: a chip shows the picked level and its live signed distance from mid in bps, with one-tap buttons that prefill the relevant offset field — slippage for IOC, limit offset for Iceberg, near/far edges for Scale, trigger offset for Stop.