No — not on its own. Ask a language model to backtest a strategy without giving it data and it will return a win rate, a profit factor and a drawdown figure that look entirely reasonable and are invented. That failure is more dangerous than a refusal, because nothing about the output signals it. With tool access to real candles, the answer changes.
Three separate limitations, each sufficient on its own.
A model's training data is not a price database. It has read a great deal about EURUSD but does not hold the open, high, low and close of 14:32 on 3 March 2023. Asked for that bar, it produces a plausible-looking number, because producing plausible text is precisely what it does.
Backtesting is arithmetic repeated thousands of times — walk the bars, check each against the rules, tally outcomes. Language models are weak at long arithmetic chains and have no way to signal that they have lost track. A tally that drifts produces a wrong win rate stated with total confidence.
Five years of one-minute EURUSD is 1,911,141 bars. At roughly 20 tokens per bar, that is on the order of 38 million tokens. No production context window is remotely close, so any pasted sample is a fragment, and a fragment chosen by hand is a biased sample.
The reason this matters is that the wrong answer is indistinguishable from a right one.
Ask an unaided model to backtest a 20-period breakout on GBPUSD H1 over 2021–2026, and you will get something like: "Across approximately 340 trades, this strategy produced a 47% win rate with a profit factor of 1.32 and a maximum drawdown of 12.4%."
That reads like a result. It has a trade count, sensible-looking ratios and a plausible drawdown. It is fiction — assembled from what backtest results usually look like, not from GBPUSD. There is no citation to check, no sample size to verify, and the model will not volunteer that it made the numbers up.
The fix is not a better prompt. It is giving the model something real to read.
Connect it to actual candle data through a tool — an MCP server, a code interpreter with a CSV, or an API client — and the arithmetic moves out of the model and into code. The model decides what to compute; something deterministic does the computing.
With that in place, the same question returns a checkable answer:
> when is EURUSD most volatile?
fxa_bucket_stats EURUSD by=hour →
14:00 UTC 2.83 pips avg M1 range
21:00 UTC 0.73
sample: 1,911,141 bars, 2021-01-03 → 2026-04-30That figure came from a function that walked 1.9 million bars. It can be re-run, and it will return the same number. The difference from the invented version is not accuracy but accountability — there is now something to check.
Tool access fixes the arithmetic. It does not make a model a trader.
The productive division of labour: the model narrows the search space over a large sample, and you take the survivors into manual replay to learn to execute them.
Any model with tool access works — Claude, ChatGPT, Gemini or a local model, provided the client can call tools. What matters is the connection, not the brand.
For MCP clients such as Claude Code, Claude Desktop or Cursor, the FXAbsolute server is three commands:
git clone --depth 1 --filter=blob:none --sparse https://github.com/varsansri/fxabsolute
cd fxabsolute && git sparse-checkout set mcp
cd mcp && npm install
claude mcp add fxabsolute -- node "$PWD/src/index.js"That exposes 28,412,683 one-minute bars across 15 instruments, with no API key. For a code-interpreter workflow instead, export the bars you need and let the model write the analysis in code — the principle is identical: the model reasons, the code counts.
The honest limit described above is about ChatGPT in the browser: it cannot install a local data server, so it cannot fetch prices it was not given. That limit is a property of the client, not of language models.
Clients that implement the Model Context Protocol — Claude Code, Claude Desktop, Cursor, Windsurf — can install one, and the install is a single line:
claude mcp add fxabsolute -- npx -y fxabsolute-mcpThat does not turn the model into a backtester. It cannot place trades, manage risk or replay a chart bar by bar, and it will still narrate confidently about things it has not measured. What it can now do is answer questions arithmetically over 28.4 million bars — how often a session broke its opening range, what the hourly volatility profile looks like, whether a level held — and show its working.
The division that holds up in practice: use an agent for systematic scanning across a large sample, and a replay tool for executing and journalling individual trades. Neither replaces the other, and a tool that claims to do both usually does one badly.
Not properly. Browser ChatGPT cannot install a local data server, so it works from training data plus whatever you paste, and it cannot execute or journal trades. A tool-capable client such as Claude Code can install an MCP data server and compute over real bars, but that is systematic scanning rather than backtesting — bar-by-bar execution still needs a replay tool.
Not on its own. A language model has no historical price data, cannot reliably perform arithmetic across thousands of bars, and has a context window far too small to hold a meaningful sample. Asked to backtest unaided it will produce plausible but invented statistics. Connected to real candle data through a tool, it can run genuine analysis.
Because producing plausible text is what it does. It has read many backtest reports and can assemble something with the right shape — a trade count, a win rate, a profit factor. Those numbers are generated, not measured. The reliable test is to ask which specific bars produced the trades; invented results cannot be drilled into.
Five years of one-minute EURUSD is 1,911,141 bars, roughly 38 million tokens. That exceeds every production context window by a wide margin, which is why the data has to sit behind a tool rather than inside the prompt.
They answer different questions. Statistical analysis over millions of bars finds where an edge might exist, far faster than a human could. Manual replay builds the execution skill to trade that edge under pressure. Neither substitutes for the other.
It can find parameters that performed well historically, which is not the same thing. Ask any optimiser for the best settings and it will return some — that is curve-fitting. Whether the result survives on unseen data is the real question, and answering it requires out-of-sample discipline the model will not apply unprompted.
The model matters less than whether it has tool access to real data. A modest model calling a function over 1.9 million bars beats the strongest model guessing from memory. Choose on the strength of the data connection first.
The free backtester runs on the same archive the tools read. Replay the bars yourself and see whether the number holds.
Open FXAbsolute →