Execution modes: paper vs live

Forven runs strategies forward in one of two ways. Paper runs a strategy on real market data and simulates every fill inside Forven — no order ever leaves your machine. Live sends real orders to HyperLiquid, but live trading is not a supported feature of the open-source build. Paper is the default and the supported way to run Forven.

This page is for anyone deciding how to run Forven. The short version: paper is the default, paper is where every strategy proves itself, and there is no switch that turns "live mode" on. A strategy sends real orders only after you promote it to the Live stage with a typed GO LIVE, and real funds take a further, deliberate opt-in.

Forven is a research tool. Paper results describe simulated behaviour and do not predict live results. Live trading is unsupported and risks real capital; nothing here is financial advice or an endorsement of trading real money with this software.

One engine for backtest, paper, and live

Forven has a single execution kernel: the code that turns a strategy's signals into positions — entries, exits, stops, take-profits, sizing, fees, slippage, and funding. The backtest walks the kernel over history. The paper and live books are driven by the same kernel in real time, through a reconciler that converges each book to what the kernel says it should hold.

That parity is the point. A strategy is validated on exactly the logic that will run it forward, so a difference between backtest and paper is a difference in the market, not in the code. Every backtest records the engine version, code identity, parameters, market, timeframe, and execution assumptions it ran on, and forward execution uses the snapshot that was accepted at promotion — a later diagnostic backtest cannot silently replace that evidence. If a paper or live strategy's settings drift from what was validated, its page shows an Execution check panel with Restore validated settings.

There is no LLM order path. No agent places, sizes, or closes positions; the Execution Trader agent was retired. Positions change only through the kernel or your own manual controls, behind the risk gates.

What decides whether an order is real

A strategy's stage does — not a global mode.

Live orders go to HyperLiquid testnet unless Settings → HyperLiquid → Hyperliquid testnet is off and FORVEN_ALLOW_MAINNET=1 is set in the backend's environment. See testnet and mainnet.

The top strip reflects this: it shows Mode: PAPER while nothing can send real orders, and Live ×N (a link to Live Trades) when N live strategies or armed bots can.

The execution_mode setting is a label

execution_mode (from FORVEN_EXECUTION_MODE, or config.json, default paper) is a global label kept for compatibility. It does not turn live trading on or off. Beta builds always report paper.

Every in-app way to set it accepts paper only:

• POST /api/execution-mode with anything else returns an error.
• Settings → Trading → Trading mode = Live is refused with a 400 ("trading_mode 'live' was not applied: Unsupported execution mode…").
• python -m forven execution mode live fails with the same error.

Beyond the label it feeds only a few fallbacks, such as the network used when no testnet setting has been saved.

# Read the current mode label, live counts, network, and risk state
curl.exe http://127.0.0.1:8003/api/dashboard

# Set paper (the only value the switch accepts; requires confirmation)
curl.exe -X POST http://127.0.0.1:8003/api/execution-mode `
  -H "Content-Type: application/json" `
  -d '{\"mode\": \"paper\", \"confirm\": true}'

Paper and live at a glance

Paper is covered in depth on the paper trading page; live monitoring lives on the live trading page.

Paper

A strategy in the paper stage of the pipeline — the stage the public site calls a "candidate" — runs forward on the live Binance feed (market_data_source, default binance), the same series its backtest validated on, and fills inside Forven. paper_stage_local_execution_only (default true) guarantees paper-stage trades never route to an exchange. Manual paper orders from the desk's ticket are local database writes filled at the cached price.

Each paper strategy trades in its own isolated session with independent starting capital (initial_capital, default 10000) and its own position set. Real-capital halts never block a paper open, and paper P&L can never trip a halt — the paper desk says "account halts don't apply to paper". Paper also sizes off the session's full equity so its track record stays comparable to the backtest.

Live (unsupported)

A strategy reaches live_graduated only through the paper → live gate and your typed GO LIVE with a per-asset notional ceiling. From then on:

• The kernel places the orders. The live path submits through the HyperLiquid SDK with a mandatory protective stop, which is mirrored on the exchange as a resting reduce-only trigger so the position stays protected even if Forven stops. Order submission is serialized with a strictly increasing nonce.
• Capital is divided, not shared blindly. Each live strategy sizes inside an equal capital slice of the account (equity / number of live strategies), so adding a strategy divides risk instead of stacking it. A per-trade clamp at order entry caps loss-at-stop at max_risk_per_trade of real equity, and the go-live notional ceiling refuses any larger open.
• Longs and shorts can live in separate wallets. Direction books route live longs and shorts to separate HyperLiquid sub-accounts.
• Positions reconcile against exchange truth. Live trades carry exchange order IDs and are reconciled continuously. A mismatch is repaired — a filled-but-untracked position gets a record, a stale claim is closed — and a single empty read is never enough to declare positions closed.
• Manual controls are real. On a live strategy, the desk's Close, Flip, stop and ticket controls place real reduce-only or market orders. Closing is never gated; a new open must pass the risk gates.

Testnet and mainnet

The network a live order hits is resolved once per order from your HyperLiquid settings: the Hyperliquid testnet toggle in Settings → HyperLiquid (default on), or FORVEN_HL_USE_TESTNET when no in-app settings exist. Every safety gate checks the network the order will actually hit. A real-funds order needs all of:

• the testnet setting off — saving that change asks you to type LIVE under "Save changes that affect real money?", and
• FORVEN_ALLOW_MAINNET=1 — the hard, default-deny real-funds gate in the exchange layer, set only in the environment, and
• a verified HyperLiquid agent (API) wallet. A master-account private key is refused on mainnet, so even a full compromise of Forven cannot move funds off the exchange.

Without FORVEN_ALLOW_MAINNET=1, any order that resolves to mainnet is refused; reduce-only exits and protective stops are always allowed. On mainnet, leverage is capped at 3× and several risk limits become fixed ceilings — see mainnet locks.

An armed mainnet gate is always visible: /api/health reports when it was first observed and how old it is. An optional expiry (mainnet_arming_expiry_hours) can disarm new entries after a set time; it is off by default because an unattended expiry at 3 a.m. would silently stop trading, and an expired arming never blocks an exit.

Forven also runs a daily testnet execution harness that places a real ~$15 testnet order and walks the whole lifecycle — open, stop mirror, trailing tighten, close — asserting exchange truth at each leg. It refuses mainnet and only ever closes what it opened. Its last result is at GET /api/ops/testnet-harness/last.

Stepping back from live

Demoting a strategy out of Live stops new live entries, but Forven won't let you strand a position: a strategy holding open live trades cannot leave the Live stage — even when forced — until those positions are closed, because only live strategies manage live exits. Close them from Live Trades, or use Emergency Halt, which closes every open live position at market and pauses the system. A system pause or a stopped backend never closes positions on its own. Reconcile before you assume you are flat.

Relevant configuration

Leave paper_stage_local_execution_only on. Turning it off would route paper-stage trades to the exchange, which defeats the purpose of the paper stage.

Caveats

• Paper is the supported mode. Live is unsupported; anyone who promotes a strategy to Live, turns testnet off and arms mainnet does so entirely at their own risk.
• "Live" means real orders, on testnet by default. The Live Trades desk says "real money" whichever network you are on; check the TESTNET / MAINNET badge.
• Paper P&L is not a proxy for live P&L. Simulation models fees, slippage, and funding, but not partial fills, rejections, or queue position — and live sizing divides the account across the cohort.
• Nothing closes positions for you except the kernel, your controls, the kill-switch and Emergency Halt. Pausing the system or stopping the backend leaves open live positions open.

Forven is a research tool. Surviving paper is evidence of disciplined process, not a prediction of returns, and nothing here is financial advice.

Related

• Paper trading — running and reading paper sessions in depth
• Live trading — the (unsupported) live monitoring view
• HyperLiquid integration — credentials, testnet, wallets, and the mainnet gate
• Going live safely — the safety machinery and why live is unsupported