The pipeline

The pipeline is the spine of Forven. Every strategy travels the same one-way road, and each stage exists to kill the strategy before the next one costs more — compute, then time, then capital. Nothing reaches real money until it has survived everything upstream.

This page maps the full lifecycle, what each stage proves, and the gate you must pass to advance. It is for anyone operating the lab: you do not need to read the code to read this, but every number here comes from the live pipeline policy.

The stages

A strategy moves through these stages, in order:

researching → backtesting → quick_screen → gauntlet → paper → live_graduated → retired/archived

• researching — an idea exists, usually spawned from a hypothesis. No metrics yet.
• backtesting — a backtest runs on historical data and produces the first metrics.
• quick_screen — cheap triage. Overfitting guardrails reject curve-fit junk in roughly five minutes per strategy, before any expensive testing is paid for.
• gauntlet — the robustness battery. Walk-forward, Monte-Carlo, parameter jitter, cost-stress, and regime-split, each proving the edge is real rather than lucky.
• paper — simulated trading against the live feed. No capital at risk. The strategy must show forward edge over a real window of days.
• live_graduated — real capital, on a staged allocation ramp, watched by a decay kill-switch.
• retired / archived — the end state, reached by manual retirement, by the decay kill-switch, or by a research_only redirect after repeated failure.

A note on names

The marketing site uses simpler words than the engine does. The map is one-to-one:

This page uses the real stage names. Where you see "candidate" on the site, the engine means paper.

How a strategy advances

Each transition is a gate. A gate reads the strategy's metrics, compares them to thresholds in pipeline policy, and either lets the strategy through or blocks it with a reason code. Gates are intentionally one-directional: passing one does not exempt you from the next.

Two ideas shape the whole design:

• Cheap-first. Tests run from cheapest to most expensive so weak strategies fail fast. Quick-screen triage costs minutes; the gauntlet costs real compute; paper costs days; live costs money. You only pay for a stage if you cleared the one before it.
• Achievable paper, strict live. The gate into paper is deliberately loose so the funnel stays active even in an adverse market. The gate from paper into live is strict, because live capital is unforgiving. Two gates, two philosophies.

Quick-screen: the overfitting gate

Quick-screen is the first real gate and the cheapest. It is a triage pass over backtest metrics that rejects the two most common ways a backtest lies: overfitting and look-ahead leaks.

A strategy is blocked from the gauntlet unless it clears every guardrail (defaults shown; some are configurable):

• In-sample Sharpe must be above 0.1, out-of-sample Sharpe above -0.1.
• The in-sample/out-of-sample Sharpe gap must stay within bounds (the engine rejects an IS/OOS ratio above 3.0).
• Profit factor must be at least 1.05 at both in-sample and out-of-sample.
• At least 30 trades (the effective count across IS/OOS) — fewer is not statistically meaningful.
• Robustness score at least 10 out of 100 — a soft floor before the expensive battery.

It also rejects implausible metrics: any Sharpe at or above 5.0 or profit factor at or above 8.0, on either IS or OOS, is treated as a look-ahead signature (for example, accidentally indexing tomorrow's bar with .shift(-1)). Honest crypto data on honest logic does not reach those numbers. This same implausibility check runs again at the gauntlet gate as defense-in-depth.

One trap worth knowing: a strategy with no distinct out-of-sample evidence is blocked, not waved through. The engine will not alias in-sample data as out-of-sample to fill the gap.

The gauntlet: robustness battery

Once a strategy clears quick-screen it enters the gauntlet — an asynchronous workflow that runs five robustness tests in dependency order, cheapest first, each persisting a pass/fail verdict before the paper gate is evaluated.

The default required set is walk_forward, param_jitter, and cost_stress; an empty required_tests list forces all five. Walk-forward is mandatory — config that drops it self-heals on next load with a warning, because dropping it would starve the gate.

Tests run sequentially because they depend on one another. A failed test stays failed at that step with no automatic retry; an operator can manually retry it. Transient blocks (a data hiccup, a runtime error) retry with exponential backoff; a slot-contention block retries on a fixed ten-minute backoff until the slot frees; a genuine gate failure does not retry.

For the full battery — fold splits, the robustness score, and how verdicts are assembled — see the gauntlet.

Paper: the achievable gate

When the required gauntlet tests pass, the strategy is evaluated against the gauntlet → paper gate. This is the lean gate, designed to be reachable even in a difficult regime while still filtering clear losers:

• Robustness score ≥ 50 / 100
• Minimum total return ≥ 0%
• Maximum drawdown ≤ 30%
• Minimum out-of-sample profit factor ≥ 1.05
• Out-of-sample Sharpe ≥ 0 (advisory)

Clear the gate and the strategy enters paper: it trades against the live market feed with simulated capital and zero risk. Paper-stage trades fill against local candle mid-prices, not the exchange (paper_stage_local_execution_only defaults to true), which keeps the run honest and free of look-ahead. Each run lives in an isolated session with its own starting capital.

Because paper fills are local and carry no exchange order ID, paper PnL is not a proxy for live PnL and does not reconcile against any exchange. Treat it as forward evidence of edge, not as a profit forecast. See paper trading for sessions, overlays, and session PnL.

Even though the paper gate is lean, its floors cannot be loosened below the built-in minimums. Config can make a gate stricter, never looser — the capital gates hard-code their floors so a relaxed setting can never bypass them.

Paper → live: the strict edge proof

The gate from paper to live_graduated is the hardest in the system, because it is the last one before real money. The strategy must prove forward edge, not just survive:

• At least 14 days in paper
• At least 50 closed paper trades
• Paper return above 0%
• Paper drawdown below 15%
• Paper Sharpe ≥ 1.0 (a per-trade t-statistic — a meaningful directional edge)
• Paper profit factor ≥ 1.2
• Historical profit factor floor for live ≥ 1.5

It also re-enforces the full robustness battery from the gauntlet and checks funding-data completeness. The numbers above are illustrative thresholds for eligibility; they are not predictions of return.

Live: allocation ramp and the decay kill-switch

A graduated strategy does not get full capital on day one. Allocation ramps on a schedule — an illustrative default of 25% in weeks 1–2, 50% in weeks 3–4, and 100% from week 5 — so a strategy proves itself with small size before it is trusted with full size.

While live, a decay kill-switch watches every strategy. If its Sharpe declines by 30% or more over a rolling 72-hour window, with at least 5 trades to confirm the move is real and not noise, the strategy is auto-retired to archived. The decay tracker is privileged: it can retire even a protected canonical strategy, because a degrading live strategy draining capital is the one thing protection must not block. Safety beats availability.

Live trading is covered in depth — shared-wallet pooling, position reconciliation, and the going-live checklist — under live trading.

Demotion, protection, and overrides

The pipeline is not purely forward-only. A few mechanisms govern what happens when a strategy fails or when you need to intervene:

• Demotion thrash protection. A gauntlet failure demotes the strategy back to quick_screen. The first and second time it remits and retries; the third demotion redirects it to research_only, out of the tradable pipeline, so a perpetual failure cannot loop forever burning compute.
• Canonical protection. The best child of a graduated hypothesis per (asset, timeframe) cell is flagged canonical and cannot be archived by automated actors — only the decay kill-switch or an operator override can clear it. This protects a proven thesis edge from accidental loss.
• Operator overrides. You can override a gate rejection — say a paper Sharpe of 0.95 against a 1.0 floor — but only through explicit, informed-consent confirmation in the UI, with a reason recorded. Capital gates can never be silently force-bypassed by automated actors. Every override is logged as a warning for audit.
• Approvals are separate. An override clears the gate; a promotion or dethrone approval still queues for manual sign-off unless auto_approve_promotions is enabled. You may need to clear both. See promotion gates for the full gate-by-gate reference.

Autonomy and the testing bypass

Two policy switches change how the pipeline runs, not what it checks:

• System mode — manual pauses all autonomous system tasks; semi_auto allows autonomous hardening but blocks new research generation; auto runs the full pipeline. Mode transitions freeze and thaw the backlog so tasks are not orphaned.
• testing_mode — bypasses the non-capital gates (quick_screen and gauntlet) for rapid iteration. It never skips the capital gates. There is no real-money bypass.

Steps: promote a strategy by hand

You can drive the pipeline manually from the strategy detail page, advancing one stage at a time.

1. Open the strategy from the Strategy Lab (/lab) or its detail page. Note its current stage in the status column.
2. Run a backtest if one is missing — a strategy with no backtest results is a phantom container and is blocked from any forward transition.
3. Click Promote to Gauntlet. The quick-screen gate evaluates; if it blocks, the rejection reason tells you which guardrail failed.
4. Let the gauntlet workflow run its required tests. Watch the step progress tracker; retry any step that blocks on a transient error.
5. When the gauntlet passes, the strategy is evaluated against the lean paper gate and, if it clears, enters paper.
6. Let paper run to the strict-gate minimums: 14+ days, 50+ closed trades, positive return, drawdown under 15%, Sharpe ≥ 1.0. Check progress on the readiness checklist.
7. Click Promote to Live. The strict paper → live gate evaluates. If you must override a near-miss, check the override box and record your reason.
8. Approve the queued promotion in the Approvals panel if auto_approve_promotions is off.

What you'll see

In the lab and on the strategy detail page, the status column shows the current stage, and a lifecycle panel shows the stage history and the next gate. When a gate blocks, the promotion dialog shows the rejection reason and — for capital gates — an explicit override checkbox. The gauntlet panel shows each test's step status (pending, running, passed, blocked). You will also see in-sample and out-of-sample metrics side by side; trust out-of-sample.

A research tool, not a forecast

Every threshold and ramp on this page is a discipline mechanism, not a promise. Forven is a research tool: paper results are simulated and do not reconcile with any exchange, live results are not predictive of future performance, and nothing here is financial advice. The pipeline's job is to make it hard for a fragile strategy to reach your capital — not to guarantee that a strategy which reaches it will profit.

Related

• The gauntlet — the robustness battery in full
• Promotion gates — the gate-by-gate reference and operator overrides
• Hypothesis-driven research — where strategies come from and how they graduate
• Paper trading — running the paper stage and reading session PnL