QuanterLab

Progress of a stochastic backtest. Returns `{task_id, status, progress, message, dashboard_url}`. When the run has finished, the answer also carries `result`, the same summary `summarize_workflow` gives, and `report_url`, the report, which the run's card in the chat shows.

get_stochastic_backtest_progress

Progress of a walk-forward started with `start_walkforward`. Returns `{task_id, status, progress, message, dashboard_url}`; progress moves window by window. When the run has finished, the answer also carries `result`, the same summary `summarize_workflow` gives, and `report_url`, the report, which the run's card in the chat shows.

get_walkforward_progress

List the single-stock fundamental analyzers available in QuanterLab. Returns each analyzer's code, human-readable name, a one-line blurb, and the list of extra parameters it accepts (beyond `ticker`). The analyzers run on quanterlab.com, from the Supplementary Data menu at the top of the site; this catalog lists what is there.

list_fundamental_analyzers

List the authenticated user's saved backtest results, newest first. Returns ID + strategy code + ticker + duration + total_trades + a categorical `performance_tier` enum (one of `promising` / `mixed` / `weak` / `unrated`) so the caller can rank or filter without seeing the underlying Sharpe / drawdown / return scalars. Each saved run opens on quanterlab.com, signed in: the sidebar's Research Library, under Reports. A run started from an assistant appears here only after `save_workflow_result`; its own report stays at the `report_url` it answered with. Args: strategy_code: Optional filter, for example "UB001UNIV", "SC001STCB", "RG001RGMO". When omitted, returns backtests from all strategies. limit: Max rows to return (1-100, default 20).

list_my_backtests

List your saved lab projects (circuits on the canvas), newest first. Each row: the project's `id`, its name, how many cards its circuit has, how many hypotheses are registered, and when it was created and last changed. The circuit, its settings and its results stay on QuanterLab, where a project opens on the canvas. Run one with `start_primitives_run` and its `id`.

list_my_primitives_projects

List the user's projects with item counts. These are the My Projects folders on quanterlab.com (saved items and notes), not the lab's circuits: those are `list_my_primitives_projects`. Returns project metadata only (name, description, category, item count, timestamps). A project's items open on quanterlab.com, under My Projects.

list_my_projects

List the person's runs that are still counted as running (at most 3 at once). Returns one row per run: its task_id, its kind, the seconds since it last reported progress, and `wedged`, true when it has reported no progress for 15 minutes and will be let go at the next start_* call. Use this when a start_* call is refused because 3 runs are already going and it is not clear which, most often after a conversation moved on in the middle of one. Read it before proposing a run's settings: `runs_left_today` is how many runs of today's allowance are left (null when the account has no daily count), and `runs_today` says it in words. Returns `{count, limit, tasks: [{task_id, kind, last_progress_age_s, wedged}], runs_left_today, runs_today, _data_policy}`. No market data, only the person's own runs.

list_my_running_tasks

List the user's saved scanner / filter results, newest first. Returns summary fields only (universe size, stocks passed, pass rate). The names each one passed open on quanterlab.com, signed in: the sidebar's Research Library, under Reports.

list_my_filter_results

List the user's saved trading configs (exported from strategy builders). Default rows carry ID + strategy_type + strategy_code + trade_count tier + categorical performance_tier, without redistributing the user's full ticker watchlist on every call. Pass `include_details=True` to opt into the full row (ticker, timeframe, primary indicator, virtual_today). Opting in is logged for audit. Args: limit: Max rows to return (1-100, default 20). include_details: When True, returns the ticker / timeframe / primary_indicator / virtual_today / config_id fields. Defaults to False to avoid redistributing the full watchlist on every list call (opting in is audited).

list_my_trading_configs

List the stochastic methods QuanterLab supports for `start_stochastic_backtest`. Returns metadata only: id, display name, category, parameters with defaults and bounds, and a short description. Use this to discover valid `primary_method.id` values for `start_stochastic_backtest`. Does NOT return any market data or fitted parameter values. Args: category: Optional filter, e.g. "mean_reversion", "trend", "pairs", "regime". search: Optional case-insensitive substring matched against method id and name.

list_stochastic_methods

List the technical indicators QuanterLab supports for strategy building. Returns metadata only: id, display name, category, parameters with defaults and bounds, and a short description of typical use. Does NOT return any market data or computed indicator values. Args: category: Optional category filter, e.g. "momentum", "trend", "volatility", "volume". search: Optional case-insensitive substring matched against indicator id and display name.

list_indicators

List the cards of QuanterLab's lab, the canvas where a strategy is drawn as a circuit of cards. On the canvas a strategy is a chain of research cards: universe, selection, signal or stochastic model, optimizer, walk-forward, forward test (the tools call a card a primitive). This returns the card catalog: each card's type, label, category, input and output ports, settings and description. Market data, saved circuits and results come from the run tools. Args: category: Optional category filter (e.g. "signal", "regime", "filter", "forward", "optimize", "factor", "autopsy", "analysis", "allocate"). search: Optional case-insensitive substring matched against block type and label.

list_primitives

How the person's strategies tracked live on paper are doing: each one's name, the day it went live, today's state in words, and its own change since it went live next to simply holding over the same days, in whole percents. Use it when the person asks how their strategy, their paper trade or their live test is doing. Nothing here places an order or moves money.

my_paper_trades

Run a backtest of an indicator rule on one stock or ETF (UB001UNIV), on daily bars. Plan: three runs a day on the Free plan (a refused call does not count); Practitioner and Research run without that daily count. A run takes about 30 seconds to 3 minutes. The call returns `{task_id, status, kind, dashboard_url}` at once. `get_backtest_progress(task_id)` reports progress; when the run has finished, its answer carries `result`: the summary in words and, for a run of a year or longer, a few rounded figures (the run's return next to simply holding the same stock over the same dates, Sharpe, worst drop, trades). The full report opens at `dashboard_url`. `list_indicators()` lists the indicators, their settings and the columns each one computes. An indicator is written `{"id": "rsi", "params": {"length": 14}}`. Args: ticker: Stock or ETF symbol (uppercase). entry_indicator / entry_conditions: The entry signal (required). exit_indicator / exit_conditions: Optional. confirmation_indicator / confirmation_conditions: Optional, a filter that must also hold on the day the entry fires. The common use is a trend filter: Larry Connors' two-day RSI pullback buys only while the close is above its 200-day average, written as confirmation_indicator {"id": "sma", "params": {"length": 200}} and confirmation_conditions [{"column": "close", "operator": ">", "value": "SMA_200"}]. timeframe: '1d' (daily bars, the only timeframe this connector runs). duration: The history tested: '60d', '6m', '1y', '2y', '3y', '5y', '10y' or 'max'. direction: 'long' | 'short' | 'both'. position_sizing: 'fixed' | 'percent_equity' (the default, as in the QuanterLab UI). risk_per_trade: Share of the account each trade uses. 1.0, the default, is the whole account, as in the QuanterLab UI; a smaller share leaves the rest in cash and scales the result down with it. Sizing across several positions (Kelly, GARCH, fixed) is handled in QuanterLab's portfolio and paper-trading tools. stop_loss_pct / take_profit_pct / max_holding_days: Optional exits. spread_bps / commission_per_trade: Trading costs (default a 10 basis point spread and no commission). oos_pct: Share of the history held back as out-of-sample, 0-100 (default 0). The run reports the in-sample part; the held-back part runs when the person presses Reveal on QuanterLab. Conditions are lists of `{"column": ..., "operator": ..., "value": ...}`; every condition in a list has to hold. operator: ">", ">=", "<", "<=", "==", "!=", "crosses_above" or "crosses_below". column: a column the strategy's indicators compute, as `list_indicators()` names it ("RSI_14"; "MACD_12_26_9", "MACDh_12_26_9" and "MACDs_12_26_9" for the MACD line, histogram and signal line), or a price field ("close"). value: a number, or another column the strategy computes (SMA_50 against SMA_200 needs an sma of each length among the strategy's indicators). Entry and exit usually mirror each other: RSI below 30 in, above 70 out; MACD crossing above 0 in, crossing below 0 out. An exit identical to its entry closes on the entry bar or never, and the run makes no trades. Example, long-only MACD momentum on PLTR over three years: start_backtest( ticker="PLTR", entry_indicator={"id": "macd", "params": {"fast": 12, "slow": 26, "signal": 9}}, entry_conditions=[{"column": "MACD_12_26_9", "operator": "crosses_above", "value": 0}], exit_indicator={"id": "macd", "params": {"fast": 12, "slow": 26, "signal": 9}}, exit_conditions=[{"column": "MACD_12_26_9", "operator": "crosses_below", "value": 0}], timeframe="1d", duration="3y", direction="long", ) A completed run can be kept in the user's library with `save_workflow_result` (the result) and `save_trading_config` (the settings), when the user wants to keep it.

start_backtest

Kick off SC001STCB's mean-reversion scanner across an index universe. Plan: three runs a day on the Free plan (a refused call does not count); Practitioner and Research run without that daily count. A scan takes about 30 seconds to 3 minutes. The call returns `{task_id, status, kind, dashboard_url}`; `get_mr_scan_progress(task_id)` reports progress and, when the scan has finished, carries `result`: each filter's rule as applied with how many names passed it, and up to ten names, those that passed every filter and then the closest misses, ranked, each with its own statistics rounded (`candidates`). `steps` is an ordered list of filters, each `{"type": ..., "params": {...}}`; a name has to pass a filter to reach the next. The filters and their settings, defaults in brackets: hurst max_h, the highest Hurst exponent that passes [0.45]; window, bars [100] halflife min_hl and max_hl, the half-life band in days [5, 100] adf max_pvalue, the highest ADF p-value that passes [0.05] kpss min_pvalue, the lowest KPSS p-value that passes [0.05] variance_ratio max_vr, the highest variance ratio [0.95]; lag, bars [5] autocorr max_acf, the highest lag-one autocorrelation [0.0] volatility min_vol and max_vol, annual volatility as a fraction [0.15, 0.60] liquidity min_dv, average daily dollar volume in millions [10] Args: steps: The filters, in order (required). index: The universe: 'sp500', 'nasdaq100' or 'dowjones'. timeframe: '1d' (daily bars, the only timeframe this connector runs). duration: The history: '6m', '1y' or '3y'.

start_mr_scan

Scan an index for pairs of stocks that move together (SC001STCB's pairs scanner). For one chosen pair (KO and PEP, say), `start_regime_analysis` with `ticker` and `ticker_b` checks that pair directly. Plan: three runs a day on the Free plan (a refused call does not count); Practitioner and Research run without that daily count. A scan takes about 1 to 5 minutes (every pair in the universe after a correlation screen). The call returns `{task_id, status, kind, dashboard_url}`; `get_pairs_scan_progress(task_id)` reports progress and, when the scan has finished, carries `result` with up to ten pairs, those that passed every filter and then the closest misses, each with its own statistics rounded (`candidates`). `steps` has the same shape as in `start_mr_scan`. The filters and their settings, defaults in brackets: correlation min_corr, the lowest return correlation [0.7] cointegration max_pvalue, the highest Engle-Granger p-value [0.05] spread_halflife min_hl and max_hl, the spread's half-life band in days [5, 60] beta_stability max_cov, how much the hedge ratio may vary, in percent [50]; window, bars [60] spread_hurst max_h, the highest Hurst exponent of the spread [0.45] johansen min_rank, the fewest cointegrating relations [1]

start_pairs_scan

Run one of your saved Primitives projects (its latest version) and return a task id to poll. The project runs at the point-in-time anchor saved with it. Get a project `id` from `list_my_primitives_projects`, then poll `get_primitives_run_progress`: when the run has finished its answer carries `result`, each branch of the project under the card name the project gives it, whether it beat simply holding what it trades over the same dates, and, for a branch tested over a year or longer, a few rounded figures. Plan: three runs a day on the Free plan (a refused call does not count); Practitioner and Research run without that daily count. A strategy with factor lanes, paper-trade markers or routers runs with Research, as on the canvas. A refusal names the primitive. The circuit and its settings stay on QuanterLab; the canvas at `dashboard_url` shows the curves and the trades. Args: project_id: The `id` of one of your saved Primitives projects.

start_primitives_run

For the report card only, which calls it while a run started from the chat goes on: how far the run is, waiting a few seconds for it to move on; when the run has finished, the card itself (its words, figures, chart and offers); when it stopped, the connector's words for why. Args: task_id: The task_id the start answered with. progress: How far the card already shows the run, in percent.

run_card_progress

Analyze one stock, or check one chosen pair of stocks (RA001RGAX). One stock: HMM regime detection, Hurst exponent, Bollinger/Keltner squeeze, Monte Carlo forward simulation. A pair (`ticker` and `ticker_b`, e.g. KO and PEP): whether the two hold together for spread trading. The QuanterLab pairs check rates the evidence that the two prices hold together as strong, mixed or weak, with a score out of a hundred, from the Engle-Granger and Johansen cointegration tests, the spread's half-life, how much the hedge ratio moves, and how often the two stocks share a market regime. It is the check to run when someone asks "is X / Y a tradable pair?" about any two stocks; `start_pairs_scan` searches a whole index for pairs instead. Plan: three runs a day on the Free plan (a refused call does not count); Practitioner and Research run without that daily count. An analysis takes about 30 seconds to 2 minutes. The call returns `{task_id, status, kind, dashboard_url}`; `get_regime_analysis_progress` reports progress and, when it has finished, carries `result`: for one stock, the regime now and how long it has run, volatility against the stock's own history, how the stock behaves (trending, mean reverting or a random walk), its trend and its drops, rounded; for a pair, how strong the evidence is that the two hold together and the check's score, the cointegration tests as p-value bands, the spread's half-life, the hedge ratio's variation, the correlation, and how often the two shared a regime, rounded. Unlike `start_regime_optimization` (RG001), which uses HMM regimes to grid-search trading thresholds, this analysis is descriptive. Args: ticker: Stock symbol (uppercased). Required. ticker_b: Optional second ticker; with it the analysis checks the pair (`ticker` / `ticker_b`) for spread trading. mode: Optional. `'volatility'` runs only the squeeze module. years: Lookback window in years (default 2). params: Optional dict overriding module-specific knobs. Most useful: `hmm_enabled` / `hurst_enabled` / `squeeze_enabled` / `mc_enabled` (disable modules); `hmm_states`; `mc_simulations`.

start_regime_analysis

Kick off RG001RGMO regime-aware threshold optimization. Adaptive threshold optimization via HMM regime detection plus per-regime grid search. Long-running (typically 2-10 min). Returns `{task_id, status, kind, dashboard_url}`; `get_regime_optimization_progress` reports progress and, when the run has finished, carries `result`. Plan: three runs a day on the Free plan (a refused call does not count); Practitioner and Research run without that daily count. Args: ticker: Asset to analyze. base_config: Strategy template, the same shape as `start_backtest`'s arguments (entry/exit indicators and conditions). param_x / param_y: The two settings to grid over, each `{"name": ..., "min": ..., "max": ...}` with an optional "steps" (2-30; default `grid_steps`). "name" is one of: "entry.length" a setting of the entry, exit or confirmation indicator ("exit.fast") "rsi.length" the same, found by the indicator's id when exactly one lane uses it "entry.conditions[0]" the number an entry, exit or confirmation condition compares against Indicator settings move in whole numbers, so a decimal setting (Bollinger's std) cannot be swept. A setting whose column another rule reads is refused with what to change. duration: Historical window (default '5y'). n_regimes: 0 to pick the number of regimes automatically (default), or 2-4. mode: 'all' (default) | 'static' | 'per_regime' | 'dynamic_mean' | 'regression', the optimizers QuanterLab's regime page offers. objective: Metric to maximize per regime: 'sharpe' (default) | 'total_return_pct' | 'profit_factor'.

start_regime_optimization

Kick off a SC001STCB Stochastic Methods backtest (OU, Kalman, etc.). Unlike `start_backtest` (indicator rules in UB001UNIV), this engine fits a stochastic model to the price series and trades from its parameters. Methods: OU mean-reversion z-score, Kalman adaptive OU, Kalman trend-following, cointegration-based pairs. Plan: three runs a day on the Free plan (a refused call does not count); Practitioner and Research run without that daily count. A run takes about 30 seconds to 2 minutes. The call returns `{task_id, status, kind, dashboard_url}`; `get_stochastic_backtest_progress` reports progress and, when the run has finished, carries `result`: the verdict and, for a run of a year or longer, a few rounded figures (the run's return next to simply holding the stock, Sharpe, worst drop, trades). With `oos_pct` above 0 the run reports the in-sample part; the held-back part runs when the person presses Reveal on QuanterLab. Use `list_stochastic_methods()` to discover valid `primary_method.id` values and parameter shapes.

start_stochastic_backtest

Kick off a UB001UNIV walk-forward optimization. Walk-forward validates that a backtest's edge is not curve-fit by sliding a rolling window: re-fits parameters on `opt_bars` then applies them out-of-sample on the next `test_bars` and steps forward. Plan: three runs a day on the Free plan (a refused call does not count); Practitioner and Research run without that daily count. A run takes about 1 to 5 minutes. The call returns `{task_id, status, kind, dashboard_url}`; `get_walkforward_progress(task_id)` reports progress and, when the run has finished, carries `result`: the verdict on the windows the settings never saw, and for a run of a year or longer a few rounded figures (their return and Sharpe next to the tuned Sharpe, how many windows made money or never traded, and simply holding the stock over the same stretch). Args: ticker: Stock or ETF symbol (uppercase). base_config: The strategy, in the same shape as `start_backtest`'s arguments (entry_indicator, entry_conditions, exit_indicator, exit_conditions, ...), with conditions written `{"column": "MACDh_12_26_9", "operator": ">", "value": 0}`. The optimizer substitutes `param_x` and `param_y` into it across the grid. param_x / param_y: The two settings to grid over, each `{"name": ..., "min": ..., "max": ...}` with an optional "steps" (2-30; default `grid_steps`). "name" is one of: "entry.length" a setting of the entry, exit or confirmation indicator ("exit.fast") "rsi.length" the same, found by the indicator's id when exactly one lane uses it "entry.conditions[0]" the number an entry, exit or confirmation condition compares against Indicator settings move in whole numbers, so a decimal setting (Bollinger's std) cannot be swept. A setting whose column another rule reads is refused with what to change, because the engine renames columns only in the swept lane's own conditions. opt_bars: In-sample window per fold (default 252 bars ≈ 1y daily), at least 30. test_bars: Out-of-sample window per fold (default 63 ≈ 3 months), at least 30. step_bars: Stride between folds. Defaults to `test_bars`. objective: Per-fold metric the grid is tuned on: 'total_return_pct' (default) | 'sharpe' | 'profit_factor' | 'win_rate'. grid_steps: Values per setting (default 3). The engine runs at most 250 backtests (every grid point in every window, plus a test run per window): five years of daily bars fit a 3x3 grid, ten years a 2x2 grid or a longer step_bars. A larger request is refused with what to change. duration: Total history to walk through (default '5y'). timeframe: '1d' (daily bars, the only timeframe this connector runs).

start_walkforward

Save the settings a run was started with as one of the person's trading configs. Saves what the person (or you on their behalf) set to start the run (ticker, indicator, conditions, risk settings). It shows under Trading configs in the Basic Strategies menu at the top of quanterlab.com, where the person can run it again. Useful AFTER you've validated a config (e.g. walk-forward looked good) so the user has it in their working library. It does not track the strategy live, and starts no paper trade: when the person asks to track it live, follow it or paper trade it, start_paper_trade does that, with a daily digest for it. Note: only saves for kinds that produce a deployable strategy (backtest, walkforward, stochastic_backtest, basic_backtest, regime_optimization). Scanner kinds (mr_scan, pairs_scan) don't have a config to save in this sense; save_workflow_result keeps their result instead. Args: task_id: The task_id returned by a prior `start_*` call. label: Optional human-readable label, max 100 chars.

save_trading_config

Save a finished run's result to the person's library on QuanterLab. The run is kept where the person finds it later, in the sidebar's Research Library on quanterlab.com, under Reports (one row with the report the run answered with): - a backtest, walk-forward, stochastic, basic or regime run, with its figures, trades, equity line and settings, opening as a full report; - a scan, with the names it passed and their settings. The run has to be finished: a save of a running task is refused with a message saying to wait for it. Args: task_id: The task_id returned by a prior `start_*` call. label: Optional name for the saved run, at most 100 characters. Without one it is named by its kind and stock ("Backtest on SPY, from an assistant"). The answer carries `report_url`, the saved report's page, and `where`, the same place described in words (the sidebar's Research Library on quanterlab.com), for apps that rewrite links.

save_workflow_result

Search QuanterLab's published research papers (registered walk-forward studies with their trials record). Returns up to 20 papers as {id, title, url}; pass an id to fetch for the paper's text. An empty query lists the newest papers.

search

Show a QuanterLab report as a card in the chat: the question, the one-sentence answer against holding the same asset, up to four figures and a growth-of-$1 chart (for a stochastic run with a parameter grid, the grid of each setting's Sharpe with the best one outlined, its cells in `grid`), a button to open the full report, and the card's next steps as choices a tap puts in the chat, with one to change a setting (on a lab run, the choices open the project in the lab, where the change is made). It is for a report with no card in the chat yet: the link summarize_workflow or save_workflow_result answered with (a backtest, walk-forward, stochastic backtest, regime analysis or optimization, scan or lab run), or a report link the person pastes. A run started in this chat shows its result in its own card, so the report_url a start or its progress tool answered with needs no second card. Call it once; then add one sentence on what the result means and ask which of the card's next steps to run, without listing them again. Args: report_url: the link summarize_workflow or save_workflow_result answered with (https://quanterlab.com/r/..., /report/..., /backtest-report/... or /filter-report/...), or a report link the person pastes.

show_report_card

Start here when a person asks what QuanterLab is or what they can do with it, says hello, asks for help, or has no rule in mind yet. It answers with what QuanterLab does (tests that guard against overfitting, 20 years of daily point-in-time data, S&P 500 tests on the companies that were in the index on each date) and the ready tests a person can run with one tap: mean reversion, trend following, momentum, buying the dip and the 200-day line, each on a stock the person names or a sensible default, plus their own idea in their own words. It starts nothing. Where its card shows, do not repeat it: add one sentence and ask which test to run. Where no card shows, give its `plain` words. When the person picks a test, run it with start_test straight away.

get_started

The summary of a run: a verdict, a headline, a short narrative and next steps. A finished run of a year or longer also carries `figures`, a few rounded results of QuanterLab's own analysis (a backtest's return next to simply holding the same stock over the same dates, Sharpe, worst drop, trades; a walk-forward's results on the windows its settings never saw). A finished scan carries `candidates`: each filter's rule as applied, and up to ten names, those that passed and then the closest misses, with their own statistics rounded. The progress tools give the same summary as `result` when a run finishes, so this tool reads a run again later. Returns: ``{task_id, kind, status, verdict, headline, narrative, next_steps, dashboard_url, figures, candidates, report_url, _data_policy}`` (`figures` and `candidates` when they apply; `report_url` for a finished run: the run written up as a report, the link to give the person) `verdict` is one of: `strong`, `promising`, `mixed`, `weak`, `failed`, `running`, `incomplete`, `unrated`. Args: task_id: A task id from any earlier `start_*` call.

summarize_workflow

Track a strategy live from the next market day, on paper, with a daily digest made for it: the lab's paper trade. This is the tool whenever the person asks to track it live, follow it, paper trade it, run it live or watch it from tomorrow, and when they tap a run's offer to track it live; asked with a run, call it as soon as that run has finished, with no question first. save_trading_config never does this: it keeps a run's settings, and nothing goes live from it. What it tracks: a finished run of this account (task_id: a ready test, a paper's circuit, a saved lab project's run, a backtest or a walk-forward), a published paper (study, from search or fetch) or one of the person's saved lab projects (project_id, from list_my_primitives_projects). It registers the strategy in the person's saved work, sets it up on paper with 100,000 for 90 days, checks it on the last six months and puts it live from tomorrow; when the check takes longer, it goes on on QuanterLab and the strategy goes live by itself when it is done. An account tracks one strategy at a time. Nothing here places an order or moves money: it is simulated on paper, on the data served each day. Its card shows what started; where no card shows, give its `message` and its `open_url`. A strategy that cannot go live as it is answers with why in `message`, and, for a paper whose data stops at its publication, an offer with the exact call of its live version. my_paper_trades says later how it is doing. Args: task_id: The task_id of one of this account's finished runs. study: Instead of task_id, a published paper's id. project_id: Instead of task_id, the id of one of the account's saved lab projects. live_version: With study, true tracks the paper's live version: the same rule on the data served today.

start_paper_trade