Strategy Arena Lab · MCP

A local backtesting MCP server: plug your AI into the Lab.The judge decides.

Strategy Arena Lab includes a local MCP server (Model Context Protocol) for backtesting trading strategies, on Windows and Linux. Claude Code, Claude Desktop, Codex, Cursor, LM Studio or opencode with DeepSeek connect over stdio or HTTP on 127.0.0.1: your AI writes rules, backtests them on your PC and searches for variants, CPU or CUDA GPU (Windows).

The Lab is a playground for AI that searches for trading strategies, with an incorruptible judge at the exit. Claude Code, Codex, opencode with DeepSeek, or a model running on your PC write rules, test them and search for variants on your graphics card. The judge then replays the chosen rule once on a period kept sealed, counts every attempt, and answers: survives, or mirage.

The download page currently serves version 0.1.0-252. Connecting your AI, the sealed proof and the Pine export work with it. It also includes the overnight autoresearch loop and the start_here path that goes through the judge first (since version 246).

What the Lab is

An AI is very good at finding a rule that worked in the past. That is exactly why it needs a judge it cannot sweet-talk. TradingView's Strategy Tester is the author's tool: it shows what the author chose to test, with no sealed period and no count of attempts. The Lab is the test that comes after. How the judge is audited and corrected in public.

claude mcp add strategyarena-lab -- node "PATH_FROM_THE_LAB"

claude mcp add --transport http strategyarena-lab http://127.0.0.1:PORT/mcp --header "Authorization: Bearer TOKEN"

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "strategyarena-lab": {
      "type": "remote",
      "url": "http://127.0.0.1:PORT/mcp",
      "headers": { "Authorization": "Bearer TOKEN" },
      "enabled": true
    }
  }
}

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "strategyarena-lab": {
      "type": "local",
      "command": ["node", "PATH_FROM_THE_LAB"],
      "enabled": true
    }
  }
}

[mcp_servers.strategyarena_lab]
command = "node"
args = ["PATH_FROM_THE_LAB"]
startup_timeout_sec = 20.0
tool_timeout_sec = 630.0

{
  "mcpServers": {
    "strategyarena-lab": {
      "command": "node",
      "args": ["PATH_FROM_THE_LAB"]
    }
  }
}

{
  "mcpServers": {
    "strategyarena-lab": {
      "url": "http://127.0.0.1:PORT/mcp",
      "headers": { "Authorization": "Bearer TOKEN" }
    }
  }
}

The path: from an idea to a judged Pine

• start_here
• →
• list_sandbox_datasets
• →
• validate_sandbox_strategy
• →
• prove_sandbox_script
• →
• export_sandbox_pine

1. start_here gives the path and the ArenaScript syntax, with ready-to-send arguments.
2. Data, then validation: the AI picks a market in the local data vault and has its script checked. An invalid script gets a named error and a minimal valid example; it costs nothing.
3. The proof: prove_sandbox_script chooses on training, then opens the sealed period once and gives the verdict, with every attempt declared counted. Backtests and GPU sweeps remain available to explore, but they describe the past: only the proof judges.
4. The Pine export of the judged strategy: the proof hands over a ready export call that keeps its window, fees, execution policy and the fingerprints of the script and data. You paste the Pine into TradingView and must find the same trades.

6 of the 6 leaderboard strategies, 234 of 234 trades, give the same trades one by one in the real TradingView, quantities included (Lab 236 export, test of 8 October 2026).

The autoresearch loop: search all night, one proof in the morning

Since version 246, an AI (or the Lab alone, with no AI) can run a research session: it proposes a rule, mutates it, sweeps its settings on the GPU, keeps what improves. That is how one would let an AI search overnight. The danger is well known: a loop that tries thousands of variants always ends up finding one that “works” on the data it sees. So the loop is fenced in:

• Counted attempts. Every script evaluated is one attempt, every GPU variant too. A duplicate is not a new attempt; an invalid script is not counted. The total goes into the deflated Sharpe and the PBO of the final proof, never reduced.
• A sealed period. At the start, the final part of the window (30% by default) is sealed and the seal is written to disk before any computation. The session only keeps training bars; it chooses on an internal validation carved out of training.
• One final proof. When the session ends, the best rule (never re-chosen) is replayed once on the sealed period, with a walk-forward in sealed blocks. A morning report shows the tree of attempts, what the loop believed, the verdict, and the exact Pine when possible.

Measured before release (11 October 2026): on pure noise, the loop believes it is improving in about 9 sessions out of 10, and the judge says “survives” in 0 of 350 sessions. On a planted signal, the loop still finds the real edge less often than the judge alone confirms it: safe, not yet efficient. That is published too. Autoresearch, the idea behind it.

What your AI cannot do

• Look at the test period. During a session, any tool that would read the sealed bars of the same market and timeframe is refused by name (autoresearch.test_period_sealed), and so is any field that would move the window. Instrumented test: 0 sealed bar seen by the engine before the final proof, 1 opening after.
• Change the data along the way (autoresearch.band_fixed) or run the final proof twice (autoresearch.session_closed).
• Erase its attempts. Abandoning a session does not open the sealed period, but its attempts stay counted for the next sessions on the same data.
• Act outside the Lab. No tool places an order, opens TradingView, publishes anything or starts a payment.

The known limit: the seal stops the AI from reading the candles, not from remembering market history it learned during training. On real data, a model knows what happened in 2022. That is one more reason the verdict also requires beating buy-and-hold, enough independent events and a majority of winning folds.

Then TradingView

The Lab exports the exact Pine of the judged strategy. You paste TradingView's List of Trades back and compare_tradingview_trades checks every trade. A free TradingView account is enough.

Before the Lab, on the Bitcoin chart: Prisme measures what you think you see, with the same chart for you and your AI.

Security: everything stays on your PC

• The Lab listens only on 127.0.0.1, with a private token you can regenerate at any time. Nothing is exposed to your network.
• Your strategies, data and results stay on your machine. The MCP connection sends nothing to Strategy Arena.
• Backtests and sweeps describe the past. Only the sealed proof gives a verdict, and it can say INCONCLUSIVE.
• The Windows installer is not signed yet: download it only from strategyarena.io and compare the SHA-256 published on the download page.

Free and Operator

Paying never changes a verdict.

When a request needs Operator, the Lab tells your AI once, in one sentence. The AI never buys anything.

Launch access

Two MCP servers, two jobs

The Lab is local and computes on your machine. The site also offers an online MCP server (https://strategyarena.io/mcp) to read the public catalogue and proofs: MCP for agents. Method: our methodology.

Educational research and backtesting tool. Past results, not a forecast. No investment advice.