# Monte-Neo strategy verifier (pypi · monte-neo)

Verify trading-strategy backtests: look-ahead probes, trading costs, Deflated Sharpe, walk-forward.

- Trust score: 89/100 (high trust)
- Change this week: +15
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- pypi · `monte-neo`: 89/100 (this document), [markdown](https://verifymcp.io/servers/neozork-monte-neo/monte-neo.md), [page](https://verifymcp.io/servers/neozork-monte-neo/monte-neo)

## Channel facts

- Registry: `pypi`
- Package: `monte-neo`
- Version: `0.54.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs hatchling.build at install time, a recognised build step with no custom scripting around it.
  - 2 of 38 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 100/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to NeoZorK/Monte-Neo).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 15 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 50/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 5619 tokens (~244/item across 23 items; 23 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 100/100
  - No destabilizing schema changes in the last 30 days.
- **Tool Coverage**: 71/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 0% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 23 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 24 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

## Install

### How do I install the Monte-Neo strategy verifier MCP server?

Monte-Neo strategy verifier runs locally as a PyPI package, launched with uvx monte-neo. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add neozork-monte-neo -- uvx monte-neo
```

### Cursor

```json
{
  "mcpServers": {
    "neozork-monte-neo": {
      "command": "uvx",
      "args": [
        "monte-neo"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "neozork-monte-neo": {
      "command": "uvx",
      "args": [
        "monte-neo"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add neozork-monte-neo -- uvx monte-neo
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "neozork-monte-neo": {
      "type": "local",
      "command": [
        "uvx",
        "monte-neo"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add neozork-monte-neo --command uvx --arg monte-neo
```

### Hermes

```yaml
mcp_servers:
  neozork-monte-neo:
    command: "uvx"
    args: ["monte-neo"]
```

### Netclaw

```json
{
  "McpServers": {
    "neozork-monte-neo": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "monte-neo"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add neozork-monte-neo -t stdio -c uvx -a monte-neo
```

### Other

```json
{
  "mcpServers": {
    "neozork-monte-neo": {
      "command": "uvx",
      "args": [
        "monte-neo"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-05 (score 89, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-10-29 (score 74, −15)

- [security regression] Malware scan: pass → unverified

### 2026-10-26 (score 89, +1)

- [security] Stability: 0.97 → pass

### 2026-10-24 (score 88, +1)

No change was recorded against any check on this day. Stability & Change Management went from 90 to 93. That category is still filling its 30-day observation window: 27 days of observed history at the previous scan, 28 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-22 (score 87, +1)

No change was recorded against any check on this day. Stability & Change Management went from 83 to 87. That category is still filling its 30-day observation window: 25 days of observed history at the previous scan, 26 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-21 (score 86, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-10-20 (score 71, +1)

- [security improvement] Malware scan: unverified → pass
- [functional] Package version: 0.53.1 → 0.54.0

### 2026-10-19 (score 70, −15)

- [security regression] Malware scan: pass → unverified
- [functional] Package version: 0.53.1 → 0.53.2

## MCP tools (23)

### `verify_strategy` (~1160 tokens)

Verify a strategy backtest and return a strategy-verdict/1 certificate.

Args:
    ohlcv_path: CSV/Parquet with open, high, low, close (optional timestamp).
    signals_path: Positions per bar (+1 long, 0 flat, -1 short, or weights in [-1, 1]) as CSV/Parquet/NPY.
    strategy_path: Python file 'path.py[:func]' defining func(df) -> positions.
        Enables look-ahead probes and static lint. Runs with your permissions.
    n_trials: Number of variants tried before choosing this one (selection bias).
    ledger: Count the variants tried on this data in .monte-neo/ledger.jsonl (hash-chained); the larger of the
        count and n_trials deflates the Sharpe. Turn it on when you try several variants.
    commission_bps: Commission per side in basis points.
    slippage_bps: Slippage per side in basis points.
    side_mode: 'long_flat' or 'long_short' (default inferred).
    warmup_bars: Bars skipped before trading (default min(60, n/10)).
    positions: 'sign' (+1/0/-1), 'weight' (fraction of equity in [-1, 1]) or 'auto'
        (weights when all values are in [-1, 1] and some are fractional).
    timeout: Seconds allowed per signal() call; the strategy runs in a worker process.
    jobs: Worker processes for the probe calls (raise for slow strategies).
    isolate: Block network, subprocesses and file writes for the strategy.
    claim: What was claimed, e.g. {"sharpe": 2.1, "total_return": 0.85, "max_drawdown": 0.12,
        "n_trades": 300} (or a JSON file path): a claim better than the verified result fails.
    funding_bps_per_bar: Funding on every open position, bps of its value per bar (default 0).
    borrow_bps_per_bar: Borrow fee on short positions only, bps of their value per bar (default 0).
    sl_pct: Stop-loss in percent of the entry price, tested inside each bar (default 0 = off).
    tp_pct: Take-profit in percent of the entry price (default 0 = off).
    trail_pct: Trailing stop in percent from the best price since entry (default 0 = off).
    symbol_…

Input parameters:

- `borrow_bps_per_bar` (number)
- `claim`
- `commission_bps` (number)
- `compact` (boolean)
- `events_delay` (number)
- `events_path`
- `funding_bps_per_bar` (number)
- `isolate` (boolean)
- `jobs` (integer)
- `ledger` (boolean)
- `model_cutoff`
- `n_trials`
- `ohlcv_path` (string, required)
- `policy_path`
- `positions` (string)
- `registration`
- `repaint` (string)
- `side_mode`
- `signal_timing` (string)
- `signals_path`
- `sl_pct` (number)
- `slippage_bps` (number)
- `strategy_path`
- `symbol_costs`
- `timeout` (number)
- `tp_pct` (number)
- `trail_pct` (number)
- `trials_from`
- `warmup_bars`

### `verify_grid` (~622 tokens)

Run the parameter search inside the verifier and verify the best combo.

Prefer this over verify_strategy when you tuned parameters: n_trials and the
spread of trial Sharpes are measured instead of declared, and an anchored
walk-forward scores re-selected parameters out of sample.

Args:
    ohlcv_path: CSV/Parquet with open, high, low, close.
    strategy_path: Python file 'path.py[:func]' defining func(df, **params) -> positions.
    grid: Parameter grid, e.g. {"fast": [10, 20], "slow": [50, 100]} (max 512 combos).
    commission_bps: Commission per side in basis points.
    slippage_bps: Slippage per side in basis points.
    side_mode: 'long_flat' or 'long_short' (default long_short).
    folds: Walk-forward folds.
    positions: 'sign', 'weight' or 'auto' (see verify_strategy).
    timeout: Seconds allowed per signal() call; the strategy runs in worker processes.
    jobs: Worker processes (the grid's combos run in parallel).
    isolate: Block network, subprocesses and file writes for the strategy.
    claim: What was claimed (see verify_strategy); compared with the verified result.
    funding_bps_per_bar: Funding on every open position, bps of its value per bar (default 0).
    borrow_bps_per_bar: Borrow fee on short positions only, bps of their value per bar (default 0).
    sl_pct: Stop-loss in percent of the entry price, tested inside each bar (default 0 = off).
    tp_pct: Take-profit in percent of the entry price (default 0 = off).
    trail_pct: Trailing stop in percent from the best price since entry (default 0 = off).
    symbol_costs: Universes only: costs by symbol, e.g. {"AAA": {"commission_bps": 2, "slippage_bps": 1}, "default": {"slippage_bps": 10}}
        (or a JSON file path). A symbol takes its own values, then "default", then the uniform costs above.
    compact: Drop details of passing checks to keep the response short.

Input parameters:

- `borrow_bps_per_bar` (number)
- `claim`
- `commission_bps` (number)
- `compact` (boolean)
- `folds` (integer)
- `funding_bps_per_bar` (number)
- `grid` (object, required)
- `isolate` (boolean)
- `jobs` (integer)
- `ohlcv_path` (string, required)
- `positions` (string)
- `side_mode`
- `sl_pct` (number)
- `slippage_bps` (number)
- `strategy_path` (string, required)
- `symbol_costs`
- `timeout` (number)
- `tp_pct` (number)
- `trail_pct` (number)

### `recheck_certificate` (~193 tokens)

Reproduce a strategy-verdict/1 certificate from its original inputs.

Args:
    certificate_path: JSON certificate written by verify (--out) or returned by a tool.
    ohlcv_path: The same OHLCV file that was verified (not for a quote certificate).
    signals_path: The same positions file (or use strategy_path).
    strategy_path: The same strategy file that was verified.
    timeout: Seconds allowed per signal() call; the strategy runs in a worker process.
    isolate: Block network, subprocesses and file writes for the strategy.
    quotes_path: The same quotes file, for a certificate issued by verify_quotes (needs strategy_path).

Input parameters:

- `certificate_path` (string, required)
- `isolate` (boolean)
- `ohlcv_path`
- `quotes_path`
- `signals_path`
- `strategy_path`
- `timeout` (number)

### `check_signature` (~87 tokens)

Check the Ed25519 signature of a strategy-verdict/1 certificate.

Args:
    certificate_path: Signed JSON certificate.
    public_key: The issuer's published key ('ed25519:<base64>' or a .pub file). Without it
        the check proves only that the certificate was not edited after signing.

Input parameters:

- `certificate_path` (string, required)
- `public_key`

### `probe_lookahead` (~154 tokens)

Look-ahead probes only: static lint, outside data, determinism, truncation, future perturbation.

Args:
    ohlcv_path: CSV/Parquet with open, high, low, close.
    strategy_path: Python file 'path.py[:func]' defining func(df) -> positions.
    timeout: Seconds allowed per signal() call; the strategy runs in a worker process.
    jobs: Worker processes for the probe calls.
    isolate: Block network, subprocesses and file writes for the strategy.

Input parameters:

- `isolate` (boolean)
- `jobs` (integer)
- `ohlcv_path` (string, required)
- `strategy_path` (string, required)
- `timeout` (number)

### `cost_stress` (~226 tokens)

Break-even cost (bps per side) and returns under 0/1/2 bars of execution delay.

Args:
    ohlcv_path: CSV/Parquet with open, high, low, close.
    signals_path: Positions per bar file (or use strategy_path).
    strategy_path: Python file 'path.py[:func]' defining func(df) -> positions.
    commission_bps: Commission per side in basis points.
    slippage_bps: Slippage per side in basis points.
    side_mode: 'long_flat' or 'long_short' (default inferred).
    positions: 'sign', 'weight' or 'auto' (see verify_strategy).
    timeout: Seconds allowed for the signal() call; the strategy runs in a worker process.

Input parameters:

- `commission_bps` (number)
- `ohlcv_path` (string, required)
- `positions` (string)
- `side_mode`
- `signals_path`
- `slippage_bps` (number)
- `strategy_path`
- `timeout` (number)

### `render_report` (~76 tokens)

Write a certificate as a self-contained HTML report for people (equity chart, checks, periods).

Args:
    certificate_path: JSON certificate written by verify (--out) or saved from verify_strategy.
    html_path: Where to write the .html file.

Input parameters:

- `certificate_path` (string, required)
- `html_path` (string, required)

### `verify_quotes` (~451 tokens)

Verify a strategy against the time its quotes really arrived; returns a strategy-verdict/1 certificate.

Use this for intraday strategies built on bid/ask quotes. A backtest that bins quotes by the exchange
stamp lets the strategy act on prices that had not reached you yet; this tool also bins them by
stamp + latency and compares.

Args:
    quotes_path: CSV/Parquet of one instrument with timestamp, bid, ask and latency_ms (or an arrival timestamp).
    strategy_path: Python file 'path.py[:func]' defining func(df) -> positions on bars of open, high, low,
        close, volume. Runs with your permissions.
    bar_ms: Bar length in milliseconds.
    commission_bps: Commission per side in basis points (default 1: quote strategies trade often).
    slippage_bps: Slippage per side in basis points.
    latency_samples: Seeded redraws of the observed latency for the Monte Carlo.
    positions: 'sign', 'weight' or 'auto'.
    compact: Drop details of passing checks to keep the response short.
    symbol: The symbol to verify when the table holds several.
    order_latency_ms: Delay from the decision to the fill in ms (the data latency comes from the quotes).
    feeds: Other symbols the strategy reads (needs symbol); their columns are prefixed by the symbol with
        non-word characters replaced by "_", e.g. ETH_USDT_X_close.
    latency_model: Assume the data latency instead of reading it: "constant:MS" or "lognormal:MEDIAN_MS,P95_MS".
    probes: Also run the look-ahead probes of verify_strategy on the arrival bars.

Input parameters:

- `bar_ms` (number)
- `commission_bps` (number)
- `compact` (boolean)
- `feeds`
- `latency_model`
- `latency_samples` (integer)
- `order_latency_ms` (number)
- `positions` (string)
- `probes` (boolean)
- `quotes_path` (string, required)
- `slippage_bps` (number)
- `strategy_path` (string, required)
- `symbol`

### `suggest_fix` (~111 tokens)

Suggest a causal rewrite of a strategy file that reads the future (negative shifts, centred windows, whole-table statistics...).

Returns the rewrites (rule, line, before, after), the patched source, a unified diff and the lint findings that
remain. The patch keeps the shape of the strategy, not its meaning: verify it with verify_strategy before using it,
and write the patched source to a new file yourself (nothing is written here). Comments are not kept.

Input parameters:

- `strategy_path` (string, required)

### `discover_indicator` (~147 tokens)

Search causal indicator formulas on a price table and verify the winner.

The search is counted (effective trials after clustering), tested against the same search on shuffled markets,
Reality Check / SPA, and a lockbox opened once. Returns found, reasons, the source of the winner, the
certificate and the search statistics (the per-candidate journal is left out). Nothing is written.

Input parameters:

- `budget` (integer)
- `cost_bps` (number)
- `evolve` (integer)
- `lockbox` (number)
- `null_runs` (integer)
- `ohlcv_path` (string, required)
- `seed` (integer)
- `side` (string)

### `register_hypothesis` (~103 tokens)

Write a hypothesis down before testing it (pre-registration, hash-chained in .monte-neo/registrations.jsonl).

Pass the returned id as ``registration`` to verify_strategy: the certificate then says whether the verified code is the
registered one. Register before the first run; a later registration does not protect against HARKing.

Input parameters:

- `hypothesis` (string, required)
- `n_trials`
- `params`
- `strategy_path`

### `compare_certificates` (~45 tokens)

What changed between two certificates: verdict, metrics, check statuses, and whether the verdict regressed.

Input parameters:

- `new_path` (string, required)
- `old_path` (string, required)

### `holdout_query` (~99 tokens)

Ask the hold-out oracle (Thresholdout) whether a strategy's hold-out result agrees with its training result.

Answers 'consistent' with the training Sharpe, or 'not consistent' with a noisy hold-out Sharpe that spends budget.
The hold-out is never shown. Initialise once with `monte-neo oracle init`.

Input parameters:

- `ohlcv_path` (string, required)
- `oracle_path`
- `strategy_path` (string, required)

### `verify_portfolio` (~52 tokens)

Verify several strategies together: effective number of independent strategies, SPA over the list, the best one deflated, the ensemble.

Input parameters:

- `ohlcv_path` (string, required)
- `strategy_paths` (array, required)

### `diagnose_data` (~59 tokens)

Known problems of a data provider's export (Binance, Yahoo, Polygon, Databento, TradingView, MT5): bar labels, time zones, units, adjustments.

Input parameters:

- `provider` (string)
- `table_path` (string, required)

### `validate_alpha` (~420 tokens)

Does a cross-sectional score predict returns, and can its top-minus-bottom portfolio be traded? (alpha-report/1)

Call it before you call a ranking signal "alpha". Family A: rank IC with Newey-West t, IC decay, quantile
monotonicity, long and short legs, breadth, permuted-score placebos, selection against timing. Family D: market
impact and participation at ``aum``, capacity curve, short feasibility, holding period against signal decay,
dependence on the rebalance day.

Args:
    prices_path: Universe prices (.csv / .parquet): timestamp, symbol, close[, volume].
    scores_path: Scores (.csv / .parquet): timestamp (or date), symbol, score; the score at t ranks returns after t.
    horizon: Forward-return horizon in bars.
    quantiles: Quantile buckets.
    claimed_ir: Claimed annual information ratio (checked against IC and breadth).
    aum: Capital you plan to run, for market impact and participation.
    seed: Seed for bootstraps and placebos.
    factors_path: Factor returns file (date + factors); default: market, size, momentum, reversal and low-volatility factors built from the universe.
    book_path: Returns of the user's existing book (date + one column per strategy): marginal Sharpe, overlap.
    n_trials: Variants tried before this one (Harvey-Liu-Zhu hurdle, minimum backtest length, Sharpe haircut).

The report also covers attribution (is it a known factor, hidden short volatility), value to a book, multiple
testing and risk (neutrality, concentration, named crises, tail risk).

Input parameters:

- `aum`
- `book_path`
- `claimed_ir`
- `factors_path`
- `horizon` (integer)
- `n_trials` (integer)
- `prices_path` (string, required)
- `quantiles` (integer)
- `scores_path` (string, required)
- `seed` (integer)

### `verify_returns` (~243 tokens)

Due diligence on a track record given only as returns (no code, no positions): strategy-verdict/1.

Smoothed returns (Getmansky-Lo-Makarov), missing small losses (a kink at zero), implausibly consistent gains, round
numbers, significance with the manager's number of strategies (Deflated Sharpe), a drawdown too shallow for the
volatility, the relation to a benchmark and a claim check. Look-ahead and costs cannot be checked from returns alone;
the report says so.

Args:
    returns_path: CSV/Parquet with a date column and a return column (decimals or percent).
    benchmark_path: Optional benchmark returns in the same format.
    n_strategies: How many funds or strategies the manager runs (prices the selection of the best one).
    claim: What the manager claims, e.g. {"annual_return": 0.18, "sharpe": 2.0, "max_drawdown": 0.06}.

Input parameters:

- `benchmark_path`
- `claim`
- `n_strategies` (integer)
- `returns_path` (string, required)

### `verify_legs` (~294 tokens)

Re-derive a spread / pairs / stat-arb strategy's P&L from its leg positions and compare it with the reported return.

Catches "phantom mean reversion": a rolling hedge ratio booked as position * change of the spread earns a profit that
no trader could (it even earns on independent random walks). The check fails (verdict REJECT, check
\``accounting_mismatch``) when more than ``tolerance`` of the reported P&L is not what the legs earned. The fix is in
\``next_actions``: book position.shift(1) * (d_y - beta.shift(1) * d_x).

Args:
    legs_path: CSV/Parquet with date, px_<leg> and qty_<leg> for every leg, and reported_return. The quantity is held
        over the bar that ends at date (decided at the previous bar); optional ``cost`` column.
    tolerance: Largest unexplained share of the P&L (default 0.05).
    pnl: "log" (P&L = quantity * change of the log price) or "simple" (quantity = fraction of equity).
    periods_per_year: Bars per year; inferred from the dates when omitted.

Input parameters:

- `legs_path` (string, required)
- `periods_per_year`
- `pnl` (string)
- `tolerance` (number)

### `build_dossier` (~217 tokens)

Write a validation dossier folder from a certificate, for a model-risk committee, a validator or an auditor.

The folder holds dossier.html (one page: summary, checks, framework map, assumptions and limitations, how to
reproduce, blank sign-off fields), dossier.json, certificate.json, environment.json, REPRODUCE.md and limitations.md.
The framework map shows evidence per clause, not compliance.

Args:
    certificate_path: A strategy-verdict/1 certificate (JSON).
    out_dir: Folder to write.
    framework: 'generic', 'sr11-7', 'ss1-23' or 'rts6'.
    name: Model name. owner: Model owner. purpose: What the model is for.
    alpha_path: Optional alpha-report/1 JSON of the strategy's signal.

Input parameters:

- `alpha_path`
- `certificate_path` (string, required)
- `framework` (string)
- `name`
- `out_dir` (string, required)
- `owner`
- `purpose`

### `monitor_live` (~250 tokens)

After launch: does the live (or paper) strategy behave like its backtest, and is the alpha dead? (live-monitor/1)

Live against backtest on the same dates (correlation, tracking error), realised slippage from fills against the
modelled one (with a recommended value), sequential alarms (CUSUM, SPRT) against the backtest edge shrunk by
\``haircut``, and the live history still needed to confirm the edge.

Args:
    certificate_or_backtest_path: The strategy's certificate (.json) or a backtest returns file (date, return).
    live_path: Live or paper returns (date, return) or fills (timestamp, symbol, side, quantity, price[, reference_price]).
    fills_path: Optional fills file when live_path holds returns.
    slippage_bps: Modelled slippage to compare with (default: the certificate's).
    haircut: Share of the backtest edge expected live (default 0.5).

Input parameters:

- `certificate_or_backtest_path` (string, required)
- `fills_path`
- `haircut` (number)
- `live_path` (string, required)
- `slippage_bps`

### `repair_strategy` (~360 tokens)

Repair a strategy's defects without overfitting it, or say why it cannot be repaired (repair-report/1).

Look-ahead and repainting are corrected first (causal rewrites, one-bar delay). Then a few declared repairs
(smoothing, holding period, no-trade band, volatility targeting, neutralisation, caps, liquidity filter) are chosen
on the first 70 % of the history by the number of defects, never by return, each counted as a trial. The rest of
the history is a lockbox opened once. Outcomes: REPAIRED (the lockbox still earns after costs and is not rejected; read its failed checks), REPAIRED_NO_EDGE
(the profit was in the defect), NOT_REPAIRABLE (what the user must do), NOTHING_TO_REPAIR. The original file is never
changed; out_dir gets strategy.repaired.py, repair.diff, certificate.json and repair-report.json/html. Do not call it
again on the same data to look for a better outcome: report the outcome as it is.

Args:
    ohlcv_path: Prices (.csv / .parquet).
    strategy_path: Strategy file 'path.py[:func]'.
    out_dir: Folder for the results.
    commission_bps: Commission per side. slippage_bps: Slippage per side.
    n_trials: Variants tried before the repair. budget: At most this many candidate repairs.

Input parameters:

- `budget` (integer)
- `commission_bps` (number)
- `n_trials`
- `ohlcv_path` (string, required)
- `out_dir` (string)
- `slippage_bps` (number)
- `strategy_path` (string, required)

### `verdict_schema` (~19 tokens)

JSON schema of the strategy-verdict/1 certificate.

### `verifier_manifest` (~21 tokens)

Execution semantics and check catalogue — read before building a backtest.

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/neozork-monte-neo/monte-neo#diagnostics

## Score history

- 2026-11-05: 89
- 2026-11-04: 74
- 2026-11-03: 74
- 2026-11-02: 74
- 2026-11-01: 74
- 2026-10-31: 74
- 2026-10-30: 74
- 2026-10-29: 74
- 2026-10-28: 89
- 2026-10-27: 89
- 2026-10-26: 89
- 2026-10-25: 88
- 2026-10-24: 88
- 2026-10-23: 87
- 2026-10-22: 87
- 2026-10-21: 86
- 2026-10-20: 71
- 2026-10-19: 70
- 2026-10-18: 85
- 2026-10-17: 84
- 2026-10-16: 84
- 2026-10-15: 84
- 2026-10-14: 83
- 2026-10-13: 35
- 2026-10-12: 24
- 2026-10-08: 35
- 2026-10-04: 64
- 2026-10-03: 64
- 2026-10-02: 63
- 2026-10-01: 63

## Common questions

### What is the Monte-Neo strategy verifier MCP server?

Monte-Neo strategy verifier is an MCP server listed in the public MCP registry as io.github.NeoZorK/monte-neo. Verify trading-strategy backtests: look-ahead probes, trading costs, Deflated Sharpe, walk-forward. This page covers its PyPI package (monte-neo).

### Is the Monte-Neo strategy verifier MCP server safe to use?

Monte-Neo strategy verifier scores 89 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 5 November 2026. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Monte-Neo strategy verifier MCP server expose?

Monte-Neo strategy verifier exposes 23 tools: verify_strategy, verify_grid, recheck_certificate, check_signature, probe_lookahead, and 18 more. Their descriptions and schemas cost roughly 5,409 tokens of context every time the server is loaded.

### Is the Monte-Neo strategy verifier MCP server still maintained?

Monte-Neo strategy verifier is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the Monte-Neo strategy verifier MCP server under?

Monte-Neo strategy verifier declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- PyPI project: https://pypi.org/project/monte-neo/
- Socket report: https://socket.dev/pypi/package/monte-neo
- Repository: https://github.com/NeoZorK/Monte-Neo
- Website: https://neozork.github.io/Monte-Neo/
- Changelog RSS feed: https://verifymcp.io/servers/neozork-monte-neo/monte-neo.xml
- Changelog JSON feed: https://verifymcp.io/servers/neozork-monte-neo/monte-neo.json
- HTML version of this page: https://verifymcp.io/servers/neozork-monte-neo/monte-neo