The independent verifier for trading strategies written by AI agents and humans.
Catch look-ahead bias, hidden trading costs and overfitting before a backtest reaches your money.

Docs · Quick start · Use from agents · Verifier API · Trap Suite · Changelog

The problem

A coding agent can turn a trading idea into a backtest in minutes. It will then tell you the strategy returns 40% a year with a Sharpe of 3. Most of the time that number is wrong, for the same few reasons:

• Look-ahead bias. The code reads future bars: shift(-1), centred windows, bfill, statistics over the whole series, np.gradient, an FFT filter.
• Missing costs. The edge is smaller than fees and slippage, or it disappears when the fill comes one bar later.
• Selection bias. The agent tried 300 variants and reports the best one as if it were the only one.

Backtest libraries run whatever code you give them. None of them tell you the backtest itself is broken.

The solution

Monte-Neo checks the backtest, not the idea. Give it the price data and the strategy code or its positions. It returns one of four verdicts, the checks behind the verdict, concrete next steps and a reproducible, optionally signed certificate.

The agent's strategy used shift(-1), so it knew the next close. Monte-Neo found the leak in four independent ways and named the line. After the fix, no look-ahead is left, and the verifier tells the truth: on a random walk, the strategy has no edge after costs.

$ monte-neo verify --ohlcv prices.csv --strategy agent_strategy.py --n-trials 40
REJECT  certificate a7f3d045f3ce046e
  check                    category    status  summary
  data_integrity           integrity   pass    OHLCV is clean
  lookahead_truncation     lookahead   fail    truncation probe: LEAK DETECTED
  lookahead_perturbation   lookahead   fail    future-perturbation probe: LEAK DETECTED
  lookahead_static_lint    lookahead   fail    static lint: negative_shift
  implausible_accuracy     lookahead   fail    next-bar hit rate 1.000
  net_profitability        economics   fail    net total return -64.97% after costs
  deflated_sharpe          statistics  fail    deflated Sharpe 0.000 over 40 trial(s)
  ...                                          (7 more checks)
→ The signal at bar t changes when later bars are removed: compute features only from rows <= t
  (no shift(-k), centered windows, bfill or full-sample stats).
→ Fix the flagged source lines (negative shift, center=True, backward fill) and re-run verify. Lines: 6.

What it checks

Every rule is backed by the Trap Suite: 50 strategies that are known to lie and 18 honest controls. It runs on every build, so the verifier cannot silently stop catching a leak or start accusing honest code.

Where to use it

Why Monte-Neo

• Independent. It checks code it did not write, with probes that do not trust the strategy's own numbers.
• Built for agents. An MCP server, a Claude Code plugin with a skill, a slash command and a reminder hook, plus rules for Codex, Gemini CLI and Cursor. Every failed check returns a next_action the agent can act on.
• Reproducible. The same data, code and n_trials always give the same certificate_id. Anyone can reproduce a certificate with --recheck.
• Signed. Ed25519 signatures show who issued a certificate and that nobody edited it.
• Honest about selection bias. Declare how many variants you tried, or let verify_grid count them for you. The Deflated Sharpe prices them in.
• Local and private. Your data and code never leave your machine. MIT licensed.

Quick start

pip install monte-neo

Command line

monte-neo verify --ohlcv btc_1h.csv --strategy my_strategy.py --n-trials 12 --out verdict.json

my_strategy.py defines signal(df), which returns one position per bar: +1 long, 0 flat, -1 short. The position decided on bar t is filled at the open of bar t + 1.

def signal(df):
    fast = df["close"].rolling(20).mean()
    slow = df["close"].rolling(80).mean()
    return (fast > slow).astype(int)

Python

from monte_neo.verify import verify_strategy

report = verify_strategy("btc_1h.csv", strategy="my_strategy.py", n_trials=12)
print(report["verdict"], report["next_actions"])

Parameter search with honest trial counting

monte-neo verify --ohlcv btc_1h.csv --strategy sma.py --grid '{"fast": [10, 20], "slow": [80, 120]}'

Use it from your coding agent

Claude Code (plugin with the MCP server, the verify-strategy skill and /verify):

/plugin marketplace add NeoZorK/Monte-Neo
/plugin install monte-neo@monte-neo

Any MCP client (Codex, Gemini CLI, Cursor, and others):

uvx monte-neo mcp

It is also listed in the official MCP Registry as io.github.NeoZorK/monte-neo. Setup for each client: Use from agents.

MCP tools: verify_strategy, verify_grid, probe_lookahead, cost_stress, recheck_certificate, check_signature, verdict_schema, verifier_manifest.

GitHub Action