Every canli-mcp tool

validate_deflated_sharpeValidate deflated Sharpe

Deflated Sharpe ratio: the probability (0 to 1) that the selected strategy's Sharpe beats the best that luck gives across the variants tried, with the probabilistic Sharpe and that luck benchmark. Send the seven statistics or a return series. With every variant's returns use validate_overfitting; luck as a trial count, validate_luck_trials; a multiple-testing haircut, validate_haircut_sharpe. A deflated Sharpe or overfitting probability above or below any threshold is not admission to anything and is not a forecast.

Arguments: observed_sharpe_annualized?: number, observations?: integer, periods_per_year?: number, skew?: number, non_excess_kurtosis?: number, effective_independent_trials?: integer, cross_trial_sharpe_sd_annualized?: number, returns?: number[]

validate_overfittingValidate overfitting (CSCV)

Probability of backtest overfitting (0 to 1) by CSCV: how often the in-sample best variant falls below the out-of-sample median. Needs every variant's returns (periods by variants); with summary statistics only, use validate_deflated_sharpe. A deflated Sharpe or overfitting probability above or below any threshold is not admission to anything and is not a forecast.

Arguments: matrix: number[][], n_splits?: integer, max_combinations?: integer, seed?: number

validate_reality_checkData-snooping tests (SPA, Reality Check, StepM)

Data-snooping tests on every variant a search tried: Hansen's SPA p-value that the best beat the benchmark only by luck, White's Reality Check, and the variants Romano-Wolf StepM finds better. Send all variants tried, not only the winners. A deflated Sharpe or overfitting probability above or below any threshold is not admission to anything and is not a forecast.

Arguments: matrix?: number[][], matrix_file?: string, benchmark?: number[], block_length?: integer, reps?: integer, seed?: integer, alpha?: number

validate_paper_evidenceValidate paper evidence

Checks paper-evidence.v0 structure and disclosures. With CANLI_LOCAL=1, record_file reads an export bundle and journal_file verifies signatures, source hashes and recomputed claims. Without a journal, source facts and signatures are unchecked. Local files are never uploaded. This verdict is about the series exactly as submitted. The service never saw the data source, its costs, survivorship, or any lookahead in how the series was built.

Arguments: record?: object, record_file?: string, journal_file?: string, signature?: {scheme,public_key,signature}

validate_breadthValidate breadth ceiling

Book Sharpe ceiling from adding sleeves of this quality and correlation, the Sharpe at a sleeve count, and the sleeves a target needs. For portfolio construction; it validates no single strategy. This verdict is about the series exactly as submitted. The service never saw the data source, its costs, survivorship, or any lookahead in how the series was built.

Arguments: sleeve_sharpe: number, average_pairwise_correlation: number, sleeves?: integer, target?: number

validate_track_recordMinimum track record length

Minimum track record length (observations and years) for an observed Sharpe to beat a benchmark at a confidence level; with observations, the record's probabilistic Sharpe so far. For live or paper records; to size a backtest for its trials, use validate_backtest_length. A deflated Sharpe or overfitting probability above or below any threshold is not admission to anything and is not a forecast.

Arguments: observed_sharpe_annualized: number, periods_per_year: number, skew: number, non_excess_kurtosis: number, benchmark_sharpe_annualized?: number, confidence?: number, observations?: integer

validate_backtest_lengthMinimum backtest length

Minimum backtest length (years) before the best of N independent trials is not expected to reach a target Sharpe by luck; with backtest_years, the most trials those years allow. For planning a search; once it has a result, use validate_deflated_sharpe. A deflated Sharpe or overfitting probability above or below any threshold is not admission to anything and is not a forecast.

Arguments: effective_independent_trials?: integer, backtest_years?: number, target_sharpe_annualized?: number

validate_haircut_sharpeHaircut Sharpe ratio

Haircut Sharpe for multiple testing (Harvey and Liu 2015): the Sharpe a single test would have needed, by Bonferroni and independent tests, and with the other tests' Sharpes, Holm and BHY. For the probability the Sharpe is real, use validate_deflated_sharpe. A deflated Sharpe or overfitting probability above or below any threshold is not admission to anything and is not a forecast.

Arguments: observed_sharpe_annualized: number, periods_per_year: number, observations: integer, tests?: integer, autocorrelation?: number, other_sharpe_ratios_annualized?: number[]

validate_luck_trialsLuck-equivalent trials

How many skill-less strategies a search would need for its best to reach this Sharpe by luck (Monte Carlo), and with a trial count, the chance it did. States luck as the best of N random tries; for the probability the Sharpe is real, use validate_deflated_sharpe. A deflated Sharpe or overfitting probability above or below any threshold is not admission to anything and is not a forecast.

Arguments: observed_sharpe_annualized: number, periods_per_year: number, observations: integer, effective_independent_trials?: integer, skew?: number, autocorrelation?: number

audit_backtestAudit a backtest

One-call audit of a strategy's returns. Headline: one test whose false-positive rate was measured on nine return shapes (White's Reality Check with variants, luck trials with Lo's correction without). Then deflated Sharpe, minimum track record and, with variants, overfitting and out-of-sample decay, each with its receipt, plus fix_next. Send every variant tried (variants_file) so trials are counted; point returns_file at a CSV instead of pasting. A deflated Sharpe or overfitting probability above or below any threshold is not admission to anything and is not a forecast.

Arguments: returns?: number[], returns_file?: string, returns_column?: string|integer, periods_per_year: number, effective_independent_trials?: integer, cross_trial_sharpe_sd_annualized?: number, benchmark_sharpe_annualized?: number, confidence?: number, variants?: number[][], variants_file?: string, n_splits?: integer

verify_receiptVerify a receipt

Verify a receipt offline: its Ed25519 signature against the bundled canlicapital.com key, its output hash and its id. Send an id to fetch it first, or the receipt itself. The receipt is content-hashed, reproducible from the open-source core it names, and signed with Ed25519 by a key published at https://canlicapital.com/.well-known/canli-receipt-keys.json.

Arguments: id?: string, receipt?: object, include_receipt?: boolean

backtest_strategyBacktest a rule over a parameter grid, validated

Backtest a rule on your prices over a whole parameter grid, then validate the best with the count of variants actually run: deflated Sharpe, overfitting probability, minimum track record, vs buy and hold, after costs. A backtest, deflated or not, is not a forecast and not advice.

Arguments: family: buy_and_hold|sma_cross|momentum|mean_reversion|breakout, grid?: object, prices?: number[], prices_file?: string, prices_column?: string|integer, dates?: string[], periods_per_year?: number, cost_bps?: number, allow_short?: boolean

summarize_seriesSummarize a price or return series

A long price or return series in about 100 words plus fields: growth, risk, dated drawdowns, trend, volatility regime, tails, jumps, stale data. Use instead of reading raw bars. Nothing here is a forecast or advice.

Arguments: prices?: number[], returns?: number[], series_file?: string, series_column?: string|integer, series_kind?: prices|returns, dates?: string[], periods_per_year?: number, benchmark_returns?: number[], name?: string

strategy_stress_testStress-test a strategy's returns

Stress a strategy's returns: bootstrap histories (how often the drawdown limit breaks or Sharpe turns negative) and named crash, volatility, repeat and stuck-position scenarios, with a fragility share. Frequencies over resampled histories are not forecasts of the future.

Arguments: returns?: number[], returns_file?: string, returns_column?: string|integer, periods_per_year?: number, paths?: integer, block?: number, seed?: integer, drawdown_limit?: number, crash?: number, volatility_multiplier?: number, outage_periods?: integer

check_feasibilityCheck a plan against broker limits and impact

Check a trading plan before it trades: broker order-rate and minimum-order limits, 2026 US day-trading rules, square-root market impact with crowding, and the capital where costs eat the return. Checks the plan as described against published broker limits and a market-impact model; it never contacts a broker or sees an account.

Arguments: broker?: alpaca|ibkr|other, asset_class?: us_equity|crypto|futures|fx|options, account?: cash|margin, capital_usd: number, orders_per_rebalance: integer, rebalances_per_year: number, turnover_per_year: number, adv_usd: number, daily_volatility: number, copies?: integer, expected_gross_return?: number, spread_and_fees_bps?: number, impact_coefficient?: number, minutes_per_rebalance?: number, orders_per_minute_limit?: number

check_leakageCheck a signal for lookahead

Does a signal look ahead? plan gives cuts; rerun your code on the first cut rows for each, then compare. Rows that changed used later rows; the result names the pattern and horizon. No code is sent. A pass covers only these cuts: the columns are the caller's, and survivorship, vendor revisions or a leak no cut reaches leave no trace.

Arguments: action: plan|compare, observations?: integer, prefixes?: integer, seed?: integer, cuts?: integer[], columns?: object, columns_file?: string, timestamps?: string[], tolerance?: number

placebo_testTest a research pipeline on placebo data

Does your pipeline find edges in noise? plan writes placebo files (your data's returns in random orders, so nothing is predictable); run the whole pipeline on real.csv and on each, then compare for a p-value that counts every choice it makes. Beating the placebos shows the pipeline finds more in the real order of the returns than in random orders of the same returns; it does not show the edge survives costs, capacity or the future.

Arguments: action: plan|compare, data_file?: string, columns?: object, kind?: prices|returns, placebos?: integer, method?: permute|block_permute|stationary_bootstrap, seed?: integer, real?: number, placebo_results?: number[], lower_is_better?: boolean

known_as_ofKnown as of a date

Get what a company had reported as of a date: per measure, the latest period filed by then, its value, and whether it was later restated; optionally ratios from those filings. For point-in-time backtests.

Arguments: company: string, as_of: string, concepts?: string[], periods?: annual|quarterly, ratios?: boolean

historyMeasure history

Get a measure (or several, with concepts) over time, newest first: latest (default), first reported, or as known on a filing date, with its filing, other version and yearly change.

Arguments: company: string, concept?: string, concepts?: string[], basis?: first_reported|latest|as_of, as_of?: string, periods?: annual|quarterly|all, unit?: string, limit?: integer

restatementsRestated periods

List periods whose value changed in a later filing, with first and latest values, % change and cause (stock splits left out by default). Omit concept to scan everything.

Arguments: company: string, concept?: string, periods?: annual|quarterly|all, since?: string, min_change_pct?: number, include_splits?: boolean, limit?: integer, offset?: integer

vintagesFiling vintages

List every filing that reported one period of one measure, oldest first: the revision history behind a number.

Arguments: company: string, concept: string, end: string, start?: string, unit?: string

list_conceptsList concepts

List the XBRL concepts a company reports and the plain names it supports, with units, periods, date range and restated-period counts.

Arguments: company: string, search?: string, limit?: integer, offset?: integer

find_companyFind a company

Find a company's SEC CIK and tickers by name, ticker or CIK. The other tools also take a name as company.

Arguments: query: string, limit?: integer

cross_sectionCross-section as of a date

Get one measure for up to 50 companies as filed by a date: each one's latest period, its value then, and whether it was later restated. For point-in-time peer and factor work.

Arguments: companies: string[], concept: string, as_of: string, periods?: annual|quarterly

search_researchSearch research

Find Canli Capital research papers (strategy tests, killed candidates, literature reviews, feasibility protocols) by words in their titles and summaries. Use it to find a paper's slug, then read it with get_paper; to browse by subject instead, use list_topics.

Arguments: query: string, limit?: integer

list_topicsResearch topics

The research topics, with how many papers each holds and what it covers.

get_paperRead a paper

A research paper's text as published, by slug, with its headings; send section for one part, and max_chars to cap the length. Find the slug with search_research or list_topics first.

Arguments: slug: string, section?: string, max_chars?: integer

trial_ledgerTrial ledger

How many distinct hypotheses Canli Capital has tried against its declared budget, and how many were killed or survived. Use it to judge any published result against the size of the search behind it.

live_recordLive paper record

The live paper-trading record (returns, costs, risk, corrections, provenance) and each sleeve's paper equity, with their limits. Use it for how the strategies are doing now; for why they exist, read the papers.

chain_headVerification chain head

The head of the tamper-evident chain that shows the published record was not rewritten after publication, with where to verify it. Use it to check that a figure you read was not changed later.

paper_accountPaper account

Read your Alpaca paper account: equity, cash, buying power, positions, open orders, the market clock, the kill switch and the local order log's verified head.

preview_paper_ordersPreview paper orders

Check orders against your paper account, live quotes, the market clock, your limits file and the kill switch; when every order passes, return a five-minute confirmation token for exactly these orders.

Arguments: orders: {symbol,side,qty,type,limit_price,tif}[], fees?: {commission_bps,per_share_usd,as_of}, limits?: object

rebalance_to_weightsRebalance to weights

Turn target portfolio weights into the whole-share orders that move your paper account there (sells first), check them, and return a confirmation token when all pass.

Arguments: target_weights: object, cash_buffer?: number, min_trade_usd?: number, liquidate_others?: boolean, allow_short?: boolean, allow_leverage?: boolean, fees?: {commission_bps,per_share_usd,as_of}, limits?: object

verify_attestationVerify an attestation

Check an attestation a pre-trade check or send returned: that it was signed by the trader's keys (Ed25519 and, where present, post-quantum ML-DSA-65; both must hold) and not altered, and, given openings from the trader's commitments file, that committed account figures are what they claim. Offline; reads nothing from Alpaca.

Arguments: attestation: {}, public_key_pem?: string, pq_public_key_pem?: string, openings?: {label,commitment,salt,value}[]

send_paper_ordersSend paper orders

Send previewed orders to your Alpaca paper account with their confirmation token (the kill switch is read again first), or cancel open paper orders by id. Every send is logged, hash-chained.

Arguments: token?: string, cancel_order_ids?: string[]

list_factorsPoint-in-time factors

The point-in-time factors pit_factor builds from SEC filings, and what each measures.

pit_factorBuild a point-in-time factor

Build a factor from SEC filings for a list of tickers, monthly from start to end, using only what had been filed by each date (restatements invisible until filed). Writes a signal CSV for backtest_signal. Values are what companies reported to the SEC in XBRL, as filed by each date; a company that files late, files outside XBRL or changes its tags can be missing.

Arguments: factor: string, tickers: string[], start: string, end: string, out_file?: string

backtest_signalBacktest a signal without lookahead

Backtest a signal against your prices: rank, long and short quantiles, rebalance, trading only on what was known lag_days earlier, costs on actual trades. Every reply holds the result against the crises its dates cover and lists the ones it does not. With capital_usd and dollar_volume_file, orders fill only as far as the market traded, pay square-root impact, and the reply shows the Sharpe at each size the market can take. Pass ledger to judge the best of a search against all of it. A backtest measures one path of history under these costs; it does not establish that the signal will keep working.

Arguments: prices_file: string, signal_file: string, rebalance?: weekly|monthly|quarterly|integer, lag_days?: integer, side?: long_short|long_only, quantile?: number, cost_bps?: number, min_names?: integer, periods_per_year?: number, capital_usd?: number, dollar_volume_file?: string, max_participation?: number, impact_coefficient?: number, crisis_drawdown_limit?: number, ledger?: string, label?: string

proof_filingsAdd company filings to a proof ledger

Add what companies filed to a signed, append-only ledger: each figure with its filing, and a restatement line whenever a later filing changes one. Re-running adds only what is new. It shows the lines were not altered afterwards, not that a figure is right.

Arguments: ledger_file: string, companies: string[], key_file?: string

proof_fileRecord a file in a proof ledger

Record a file's hash in a signed, append-only ledger, a backtest result or a returns file, so anyone can later check this exact file existed by then. Nothing else about the file is claimed.

Arguments: ledger_file: string, file: string, label: string, kind?: backtest|returns|league_entry|other, key_file?: string

proof_verifyVerify a proof ledger

Check a proof ledger from the file alone: every hash, order and signature, and any heads published elsewhere. Says which line first fails.

Arguments: ledger_file: string, anchors?: {seq,hash}[]

proof_findLook up a proof ledger

Look up a file, company or concept in a proof ledger. No record means only that this ledger holds none, not that anything is wrong.

Arguments: ledger_file: string, sha256?: string, file?: string, company?: string, concept?: string, kind?: figure|restatement|file, limit?: integer

league_newStart a paper league

Start a paper league: a schedule of rounds and rules with a hash to publish. No prizes, no stakes and nobody's money.

Arguments: league_dir: string, name: string, first_close: string, rounds: integer, days_per_round?: integer, min_names?: integer

league_commitCommit a league entry

Commit a league entry before its round closes: only the hash of its CSV of ticker,score goes in the ledger, and the file is shown after the round. Only the latest commit counts, so revealing whichever of several did best is refused.

Arguments: league_dir: string, round: string, entrant: string, file: string, entrant_key_file: string, key_file?: string

league_scoreScore a paper league

Score a paper league from its files and prices, repeatable by anyone: each entrant's rank correlation with what followed, set against the best luck gives across that many entrants, how different each is from the rest, and a paper book of the top entrants chosen on earlier rounds only.

Arguments: league_dir: string, prices_file: string, book_size?: integer

exchange_newStart a paper exchange

Start a paper exchange where different AI agents and scripted traders (market makers, momentum, value, deleveragers, stop-losses, levered longs) trade in limit order books, with margin rules and forced selling, plus shocks at set steps. Made-up assets and money, reproducible from a seed.

Arguments: exchange_file: string, seed?: integer, assets?: integer, personas?: {market_maker,value,momentum,noise,deleverager,stop_loss,levered_long}, starting_cash?: number, maintenance_margin?: number, leverage?: number, shocks?: {step,kind,asset,percent,steps,quantity}[]

exchange_joinJoin a paper exchange

Join a paper exchange as an agent. Returns the token its other calls need, so no agent can act as another.

Arguments: exchange_file: string, agent: string, about?: string

exchange_viewSee a paper exchange

What an agent in a paper exchange can see: the books, recent trades and its own account. No other agent's positions.

Arguments: exchange_file: string, agent: string, token: string, depth?: integer

exchange_ordersSend orders to a paper exchange

Send an agent's limit orders, market orders and cancels for the coming step of a paper exchange. An empty list passes.

Arguments: exchange_file: string, agent: string, token: string, orders: object[]

exchange_stepMove a paper exchange on

Move a paper exchange on. Waits for every joined agent to act, so nobody moves time on the others.

Arguments: exchange_file: string, steps?: integer, force?: boolean

exchange_reportReport a paper exchange

What happened in a paper exchange: each asset's worst fall and recovery, spreads and depth, who gained and lost, forced selling and the longest chain of it, and a hash anyone can check by replaying.

Arguments: exchange_file: string

exchange_runRun a whole paper exchange

Run a whole paper exchange of scripted traders in one call and report it: for comparing set-ups, such as how much leverage turns a shock into a cascade. A simulation, not a forecast.

Arguments: seed?: integer, assets?: integer, personas?: {market_maker,value,momentum,noise,deleverager,stop_loss,levered_long}, starting_cash?: number, maintenance_margin?: number, leverage?: number, shocks?: {step,kind,asset,percent,steps,quantity}[], steps: integer

agent_consensusCombine agents' forecasts and count independent views

Combine several AI agents' probabilities, and count how many independent views they really hold, from how their errors move together: five models that share their mistakes are not five votes. Weights each by its record on settled questions.

Arguments: agents: {name,forecasts}[], outcomes?: {question,happened}[]

find_diversifiersFind what diversifies a book

Rank candidate strategies by what they add to a book: independent bets added first, then how they behave on the book's worst days, with return shown last and never used to rank. Correlation first.

Arguments: book_file: string, candidates_file: string, limit?: integer, min_days?: integer

arena_newStart a paper arena

Start a paper market for AI agents to trade in: made-up assets and made-up money, with scripted traders, reproducible from a seed. Nothing here represents or reaches a real security, token or currency.

Arguments: arena_file: string, seed?: integer, assets?: integer, starting_cash?: number, bots?: integer

arena_ordersSend paper orders to an arena

Send paper orders for an agent in an arena, for the coming auction. No short selling and no borrowing.

Arguments: arena_file: string, agent: string, orders: {asset,side,quantity,limit}[]

arena_stepClear a paper arena

Clear a paper arena's next call auctions at one price per asset, and show prices and standings. Paper only.

Arguments: arena_file: string, steps?: integer

crisis_replayReplay strategies through named crises

Hold any strategy's daily returns against named market crises (2000-02 dot-com bust, 2008-09 bank crisis, 2011 US downgrade and euro debt scare, 2013 taper tantrum in bonds and others): its return, drawdown and worst day in each one its dates fully cover, and the crises it was not there for, listed as untested and never as passed.

Arguments: returns_file: string, drawdown_limit?: number

cpcvCombinatorial purged cross-validation

Combinatorial purged cross-validation of a search: choose the best trial on training days, score it on held-out blocks, with purge and embargo at the edges, for every choice of blocks, stitched into whole paths. Returns the spread of out-of-sample Sharpes against the in-sample one. Splits can run as shards on other machines and merge back. Paths share days and data, so their spread is not a confidence interval and they are not independent tests.

Arguments: returns_file?: string, groups?: integer, test_groups?: integer, purge_days?: integer, embargo_days?: integer, periods_per_year?: number, shard?: {index,of}, out_file?: string, merge_files?: string[]

price_panelBuild a price panel

Build a price panel from free sources for breadth_book or backtest_signal: the tickers you name or an index fund's current holdings, daily adjusted closes and dollar volume, and each company's Fama-French industry from its SEC SIC code, written as CSV files.

Arguments: tickers?: string[], index_fund?: string, max_names?: integer, start: string, end?: string, out_dir?: string

breadth_signalsBreadth lab signals

The cross-sectional signals breadth_book builds sleeves from: momentum, reversal, low volatility and beta, idiosyncratic risk, lottery demand, skewness, price delay, seasonality and liquidity, each with its formula's source and the data it needs.

breadth_bookBreadth book of sleeves

Build many weakly correlated sleeves (every signal inside every group of names) from your price panel and trade them as one netted account, ALPHAC's breadth lab: rank-weighted within each group, overlapping portfolios, hedged and scaled to a volatility target, costs on actual trades. Returns the book netted and standalone, the netting ratio, effective independent bets and ideas, and writes every sleeve's returns as a training dataset. A sleeve built on many signals and groups is a search: report the number of sleeves, keep a period untouched for the test, and judge the book there, not on the years used to choose it.

Arguments: prices_file: string, groups_file?: string, dollar_volume_file?: string, signals?: string[], min_names?: integer, smoothing?: integer, cost_bps?: number, target_vol?: number, split_date?: string, out_file?: string, ledger?: string

breadth_sweepParallel sweep of breadth settings

Run a grid of breadth-book settings (signal sets, smoothing, target volatility, costs, minimum names) in parallel on every core of this machine, or as shards other machines run and merge_files joins. Every combination counts as a trial: the best Sharpe is set against what the best of that many trials reaches by luck, and with split_date the chosen settings are scored after the split.

Arguments: prices_file?: string, groups_file?: string, dollar_volume_file?: string, grid?: {smoothing,target_vol,cost_bps,min_names,signals}, split_date?: string, workers?: integer, shard?: {index,of}, out_file?: string, merge_files?: string[]

effective_betsEffective independent bets

How many independent bets a set of return series holds: the participation ratio of their weekly correlations (n for unrelated series, 1 for copies), and with families, the families' bets and the ideas they cluster into.

Arguments: returns_file: string, family_separator?: string, threshold?: number

annotation_packetAnnotation packets

Start a labelled dataset: figures (company, measure, period, value) are checked by machine against the SEC filings and written as blind CSV packets for two or more people to label, with guidelines and a key holding the machine labels.

Arguments: task: string, items?: {company,measure,period,value,unit,note}[], items_file?: string, text?: string, company?: string, annotators?: integer, assisted?: boolean, out_dir?: string

annotation_agreementAnnotation agreement

Read filled annotation packets: how often the people agree (Cohen's kappa), how often they agree with the machine, and every disagreement.

Arguments: task_dir: string

annotation_goldAnnotation gold set

Merge filled annotation packets and a reviewer's decisions into a gold dataset (JSONL: each item's label, who decided it, the machine label and source) with a datasheet of agreement and hashes.

Arguments: task_dir: string, reviews?: {item_id,label,correct_value,note}[]