Strategy API (ctx)

A strategy is one JavaScript function. Backtest and live use exactly the same interface — nothing exists on only one side.

function onUpdate(ctx) {
  // called per candle (backtest) / per update (live)
  // return null, one order object, or an array of orders
}

What can you build?

• Markets: Upbit & Binance spot, Binance USDT-M & COIN-M futures — leverage, long/short, isolated/cross margin.
• Multi-symbol scanner: one strategy watches many symbols (up to 200) on the same exchange — per-symbol positions, orders and state, separated automatically.
• Ordering on two exchanges from one strategy (legs — cross-exchange arbitrage/hedging): backtests (incl. jobs), paper AND live real orders are supported. Per-leg wallets, fees and an interlocked kill-switch; live requires API keys for every leg before it starts (no half-executed hedge, no silent downgrade). P&L of legs in different currencies is never aggregated (an approximate USD figure is shown for reference only).
• Aux-symbol reference: use another symbol/exchange's price as a signal (ctx.ref slots — e.g. watch Binance BTC while trading on Upbit). Works in backtests, paper and live.
• Multiple exchanges at once: you can also launch one run per exchange — a single agent holds keys for several exchanges and runs them all in parallel (strategy A on Upbit + strategy B on Binance futures).
• Multi-agent cluster: scanner symbols are distributed across several agents automatically and run in parallel (Elite plan + onboarding required).
• Data: candles (1m–1d), volume, orderbook, funding rates, open interest/liquidations, macro series (dollar index, US 10y yield, Nasdaq-100, gold — ctx.macro), real FX rates (USD/KRW — ctx.fx; premium math is yours) and external signals (webhooks). Unknown values are null — never faked as 0.
• Orders: market, limit, split entries, live-only smart orders (chasing/trigger).
• Safety: order caps (guardrails), fee-aware loss kill-switch, dry-run.
• Validation: backtests up to 100k bars, walk-forward via fixed end dates, plus a per-tick decision-time estimate in the studio and a live tick monitor (see on the run card whether your server keeps up).

Not supported yet (we don't pretend otherwise):

• Splitting legs across different agents — today one agent holds the keys for every leg and executes them all. The compute-central/execute-edge architecture is in development.
• Automatic cluster rebalancing — distribution is static. If an agent drops, its symbols wait and the UI says so honestly (they are not silently moved).
• Stock (KIS) deploys/live trading — stock candle data and backtests only for now.

Rules

• Pure function — no network, no imports, no async. Only the ctx below.
• qty is always an amount of coin (not cash).
• Indicators return null without enough data — always null-check.
• Keep your variables in ctx.state; they persist across calls.
• ctx.ref slots use logical names ('hedge' etc.) — real symbols are bound at deploy time.

Order objects

• Market: { side: 'buy'|'sell', qty } — walks the book (slippage, partial fills, taker fee).
• Limit: { side, qty, type: 'limit', price } — fills at your price with maker fee when touched. postOnly: true rejects a limit that would fill immediately.
• Smart (work order): { side, qty, type: 'smart', chase?, slices?, trigger?, hardStopMs? } — executed over time: chasing (peg the book → cross at deadline), slicing, stop/trailing triggers, and a hard time budget, in live and paper runs. Backtests approximate it as a market order — validate with a live paper run.
• Cancel all: { cancel: 'all' } — cancels resting limits AND all work orders (chasing can't be stopped by canceling a single order).

The table below is the entire ctx (generated from the same source as the editor autocompletion). To get strategy code from an AI, use Create an AI Strategy or paste the whole AI reference.