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.

Every algo on this page is a mechanical executor: it forwards the orders you arm, on the parameters you set, as a pre-committed rule — it cannot choose to do anything else (Terms of Use). How that claim is drilled and proven is on How the Engines Are Tested.

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 — the transitional rail that collects accrued construction fees). 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 forwards the order to 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), and only because you toggled close mode — it never chooses to close. Every child order is reduce-only, and the position can only shrink.

HIP-3 builder markets arm through the same single-coin algos as any other market — pairs don't include them yet (the pair pipeline is main-listing today; HIP-3 pair support is coming). A HIP-3 deployer can scale the venue's trading fees: when a market carries a fee multiplier, the pre-flight shows an amber fees ×N chip before you arm. HIP-3 positions margin separately per builder market — the wallet page reports them as per-market subtotals rather than folding them into the headline margin numbers.

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:

• Arrival Price (IS) — an Almgren–Chriss optimal schedule with an urgency dial; impact parameters calibrate from our own fill journal.
• SnapBack — per-slice aggression set by the live z-score: presses when the spread is stretched, idles at the mean.
• 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 Methodology 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.

PEATS (manual ticket)

What it does — the PErpetuals Automatic Trading Screen: the manual ticket, keyed the way the old exchange terminals took orders — ACTION · QUANTITY · SECURITY · PRICE, left to right, then arm. No engine loop and no schedule: one venue order built from what you typed — a market cross, or a limit resting GTC, IOC, or add-liquidity-only — with optional take-profit and stop triggers alongside. The price cell speaks a grammar, not a number: 85111 is an absolute price, +150 and -2% are offsets from the live mid, mkt crosses now, join rests at the touch maker-only. Quantity takes USD (25k), base units of the coin (0.5u), a percent of available margin (50%), or a bare 1–4 — your four editable preset size chips.

The keyboard — the ticket drives without a mouse (desktop only). Space summons it on any cockpit and, once inside, walks the strip QUANTITY → SECURITY → PRICE (Shift+Space retreats; Tab works too). B / S set the side whenever no field has focus. SECURITY type-aheads the whole market universe — Enter on a new coin navigates the cockpit there with the ticket intact. Enter from PRICE arms; a second Enter confirms (the house two-click). Esc clears the ticket; a second Esc collapses the console. While a ticket is live the page wears the side — an emerald or rose frame — so a half-keyed order is never ambiguous.

Status — live: armable by any connected wallet that has enabled trading. The ticket prices itself against the live mid in your browser and the pre-flight echoes the resolved price, notional, and estimated fee; then the server re-parses your price and size grammars with the same rules, re-runs every gate, and the engine resolves your price against a fresh mid and places one venue order with your flags — plus the optional TP/SL trigger pair — and steps aside. A resting GTC or ALO belongs to the exchange from that moment: the run completes as resting at venue and the order lives on the book under your wallet. Venue order minimum: $10.

Where it fits — you know the price you want and keying it beats clicking for it: this is the only ticket on the desk that takes an absolute limit price, a plain resting GTC, a reduce-only exit at your number, or a one-liner with TP/SL attached. Where it doesn't — size that moves the book (the algos on this page exist to hide exactly that — this ticket shows your whole hand in one order), or anything that should be worked over time or re-pegged as the market moves (Adaptive and the slicers do the working).

Watching & fills — an IOC either fills on arrival or dies; the result lands in the fill rail like any other print. A resting limit lives on the exchange book itself — venue truth: the working-orders strip on the ticket lists every working order under your wallet (cancel is a two-tap on the row), and the chart marks each standing order's price with a dotted line.

Stopping & asleep — there is nothing to pause: no engine is running. A resting order cancels at the venue; what already filled is yours — cancel is not undo.

Costs — venue taker fee on a cross, maker fee on a rest, and no construction fee: the builder field is omitted from the order entirely. One order is roughly one venue action — the lightest rate-budget footprint on this desk, and the loudest market fingerprint per dollar: the whole size prints or rests at once.

Worst day — fat fingers love a powerful grammar: -2% is not −2 ticks, and +150 is price units of offset, not percent. The pre-flight echoes the resolved price before you arm — read it back the way the old floor read back an order. And a limit left resting is a free option you wrote to the market: a rest you have stopped watching should be a cancel.

Quant corner — there is no model. The grammar resolves as: absolute is yours untouched; ±Δ = mid + Δ; ±p% = mid × (1 + p/100); mkt crosses IOC; join rests at the touch add-only. The only quant content on this ticket is the arithmetic you typed.

Adaptive Market

What it does — part maker, part taker: which one is set by a pre-committed tick-and-time schedule, not a judgment. 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 on that schedule, the dwell shrinking by rule 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.

Where it fits — 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. Where it doesn't — a one-tick spread (nothing to walk — IOC gets there sooner), or a session average is the aim, 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. Construction fee: 1 bp — journaled at build, rebated if nothing fills, collected per fill by the transitional builder rail.

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 — a pre-committed “stop waiting when…” condition, never a judgment call. Modeled on IBKR's Adaptive Algo, documented to beat plain market/limit on average because most spreads are wider than a tick.

Tuned in testing — the urgency dwells (patient 8s · normal 3s · fast 1s) came out of a dwell sweep in the engine's simulator: seconds-scale wide-spread fixtures, two tape tempos, twenty fixtures each, multiple seeds. What the sweep measured: normal 3s was the busy tape's cost minimum (~0.1 bps, against ~29 bps for the IOC cross on the same fixtures); fast 1s paid ~3 bps more to finish ~40% sooner; patient 8s was cost-flat against normal on both tempos — the conservative maker model credits no queue position, so sitting longer bought passivity, not a measurably cheaper fill. All three settings completed every fixture. The "meaningful fill" floor that resets the rung timer was also set by testing — 5% of remaining size, after a grind fixture showed sub-1% maker crumbs resetting the timer while the market ran away. The escalation curve itself (the dwell halves per adverse far-touch tick) is a fixed rule, not a swept value. Fixture measurements, not live-tape promises.

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.

Where it fits — you want the position now and the pre-flight says one clip clears inside your cap. Where it doesn't — a ticket more than a few percent of the visible book: you are the market, and a slicer or Iceberg spends that 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. Construction 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.

Where it fits — set-and-forget with the strongest uptime story available, and nothing to mistune. Where it doesn't — 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. Construction 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.

Where it fits — an average price over hours, with the pre-flight's "maker saves" line meaningful at your size. Where it doesn't — the position is needed 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. Construction fee: 1.5 bp — journaled at build, rebated if nothing fills, collected per fill by the transitional builder rail.

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 you set bounds 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).

Defaults — two fixed engine constants: a behind-schedule catch-up cross is capped at three slices' size in one clip (the venue TWAP's own convention), and three consecutive zero-fill completion crosses read as a venue post-only window — the engine pins the remainder post-only at the cap and waits, instead of hammering.

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.

Status — preview: configure it, chart the schedule, and price the pre-flight today; arming is marked coming soon on the Arm button itself. The sections below describe the engine it ships with.

Where it fits — size that needs weeks and a daily check-in, not babysitting — needing more than one blotter glance is a design failure, ours not yours. Where it doesn't — a job that 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. Construction fee: 2 bp — journaled at build, rebated if nothing fills, collected per fill by the transitional builder rail.

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.

Where it fits — a ticket that is a large fraction of the visible book, held with a price and patience: supplying liquidity and getting paid the maker rate to wait. Where it doesn't — certainty of completion is required: 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. Construction fee: 0.7 bp — journaled at build, rebated if nothing fills, collected per fill by the transitional builder rail.

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.

Defaults — the sliver draw is ±20% around your display size, the venue TWAP's own randomize convention; draws are seeded per parent and slice, so a restart replays the same sequence instead of rolling new dice.

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 touch, always maker, never crossing — until the optional give-up timer says cross now.

Where it fits — 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. Where it doesn't — a tape 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. Construction fee: 1 bp — journaled at build, rebated if nothing fills, collected per fill by the transitional builder rail.

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.

Where it fits — range accumulation (a zone, not a price) or fading a move with conviction expressed as geometry. Where it doesn't — 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. Construction fee: 0.7 bp — journaled at build, rebated if nothing fills, collected per fill by the transitional builder rail.

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. The level field speaks a grammar: an absolute price (0.0052) is exact — it freezes the moment you arm, and the worker validates it against a fresh mid at launch, refusing by name if it is already breached, inside the minimum distance, or absurdly far; an unsigned distance (1.5%, legacy bps) resolves off the live mid at launch — mid plus your offset, snapped to the venue grid, shown resolved in the blotter. Arm posts your level to the create endpoint, the server re-validates it against the same schema the form was generated from, and the worker engine 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 measured against the trigger itself, not arrival — trigger slippage is this order's honest number. Venue order minimum: $10.

Where it fits — protection that must not depend on anyone's uptime, ours included, or an exit or breakout entry pre-committed at a level, decided calmly now. Where it doesn't — expecting 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. Construction 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. Each leg's field speaks a grammar: an absolute price, or an unsigned % of your position's ENTRY price — both exact, frozen the moment you arm, with the PnL at each level shown against entry before you commit, and validated by name against a fresh mid at launch (breached, too near, too far all refused); legacy bps distances resolve off the live mid at launch. Arm posts your levels to the create endpoint, the server re-validates them against the same schema the form was generated from, and the worker engine stages two position-tied venue triggers, snapped to the venue grid, shown resolved in the blotter. 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 measured against the fired leg's own trigger. Venue order minimum: $10 (full closes exempt).

Where it fits — an open position with both exits standing — target and protection — without depending on anyone's uptime, ours included. Where it doesn't — flat (the Stop / Take desk covers entry-side triggers), or expecting 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

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.

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 cuts your window from the coin's stored volume curve — 96 UTC 15-minute buckets averaged over a rolling 28-day window of our own candle archive — sizes one child per bucket in proportion to its weight, and works the parent like TWAP+: maker-first, a capped IOC only when fills fall behind the curve. Coins with fewer than 14 sampled days of history are refused by name at launch, never sliced blind; a window with no measurable curve degenerates to even slices and says so. A bucket too small to carry the venue's $10 child minimum merges forward into the next one, never silently dropped. The finish is measured against the parent window's interval VWAP computed from the same candle archive. Venue order minimum: $10 per child (mean-child gate on the form; full closes exempt).

Where it fits — being judged against the whale-standard benchmark, or a coin with a strong intraday rhythm. Where it doesn't — a coin that trades flat around the clock: VWAP degenerates to TWAP and the extra machinery buys nothing.

Stopping & asleep — pause pulls the resting child; resume re-anchors to where the curve is now — buckets that passed while paused roll into the behind-curve deficit and come back as capped catch-ups, so the parent finishes with the session, not against a stretched clock. Cancel pulls every resting child immediately; what filled is yours. Restart-safe by client order id: a worker deploy rebuilds the exact launch schedule from the journal and never duplicates a child.

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 coin's stored intraday profile, renormalized over the chosen duration. 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)

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.

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 subscribes to the coin's live trades for the parent's lifetime, measures everyone else's volume — your own prints are excluded before the division, because counting them would let your own trading justify more of your own trading — and releases children sized to hold your share at the cap: maker at the touch where the slack allows, a bounded IOC inside the slippage cap when participation falls behind. The cap that makes the promise is cumulative since launch, so a child that fit when placed can never breach later; a rolling window paces the releases and pulls the resting child when the tape dies under it. Runtime is unknown by design: the expiry bounds it, and whatever remains at expiry is named in the verdict, never chased. If the live trades pipe drops, pacing degrades to a candle poll and says so in the journal. Venue order minimum: $10 per child (full closes exempt).

Where it fits — mandate-style flow: "be no more than x% of the volume" as a hard promise. Where it doesn't — a completion time is required: 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.

Stopping & asleep — pause stops releasing children; volume that trades while paused is volume you never participate in — there is no catch-up, because catch-up would break the cap. Cancel pulls the resting child immediately; what filled is yours. Restart-safe by client order id: a worker deploy restores the participation ledger from the journal and re-primes the tape window from candles, never assuming zero volume.

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 — every child fits inside cap·tape − own, where tape is everyone else's volume since launch — both figures only grow, which is what makes the ceiling provable rather than aspirational; a rolling window paces the releases and triggers the bounded catch-up. 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.

Where it fits — you can say which you fear more — a worse average from pushing, or drift while you wait — and that answer turns directly into the schedule. Where it doesn't — the shape is already known (even slices is TWAP+, the tape's rhythm is VWAP), or cold-start coins: impact parameters calibrate from our own fill journal, and no journal means no calibration.

Watching & fills — the scheduled curve front-loads relative to TWAP's straight line, spending early while remaining inventory — and therefore variance exposure — is largest. Behind-schedule 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 — per-slice aggression is a set function of the live z-score of the spread: stretched, it presses; at the mean, it idles. The schedule serves the signal, not the clock.

Where it fits — statarb entries where "when" matters more than "how fast". Where it doesn't — no view on the spread (a z-modulated schedule without a signal edge is noise-chasing with extra steps), or completion by a time is required.

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.

Where it fits — 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. Where it doesn't — 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 Watch-list 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.

Where it fits — entering or exiting a pair position at size, where legging in by hand is itself the risk. Where it doesn't — one-leg conviction: a pair algo keeps 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.

Where it fits — 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. Where it doesn't — both legs deep and tight, or a hedge book carrying 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.

Defaults — one fixed engine constant: the hedge is retried through venue refusals, but after five consecutive rejections the order stands down with the naked residual stated — a clip the venue keeps refusing surfaces as a problem, never a silent retry loop.

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.

Where it fits — building a pair position over days where entry quality in σ matters more than entry time. Where it doesn't — 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 ticket 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.
• Construction 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.

Construction fee — our per-algo schedule

Our fee is a construction fee — a software fee journaled to your tab when the terminal builds an order from your parameters, and rebated automatically if the construction never fills (partial fills rebate the unfilled fraction). It 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 — 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. On filled constructions that transitional builder rail is how the accrued fee is collected — one fee, collected once, never twice; the reconciliation ledger on your account page credits back any over-collection, and every account opens with a USD 20 construction credit that offsets these fees. 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 field — slippage for IOC, limit offset for Iceberg, near/far edges for Scale (as bps distances), and the trigger-level fields for Stop and Bracket as the absolute price itself. On those two, a chart click also lands directly in the level field you last touched.