> ## Documentation Index
> Fetch the complete documentation index at: https://docs.askfutures.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Validate your strategy
> Three ways to check that the backtest you're reading matches the strategy you described — inspect every trade visually, audit the exported data, and lean on the automated rules review.
A backtest is only as useful as your confidence in it. When AskFutures turns
your plain-English strategy into rules and replays them over real historical
prices, you shouldn't have to take the results on faith. This guide covers the
three ways to check the work, from a quick visual once-over to a full audit of
the raw numbers.
The numbers themselves come from a fixed, deterministic simulator — the AI
never invents performance figures (see
[Is the backtest real?](/concepts/is-the-backtest-real)). Validation is about
the layer above that: confirming the rules being simulated are the strategy
*you* meant, and that each trade behaved the way you intended.
## 1. Inspect every trade visually
Open your strategy card and click the **Trades** tab. Every trade from the
backtest is there — entry and exit times, long or short, time in trade, P\&L,
and how far each trade moved against you (MAE) and in your favor (MFE). Sort
the whole backtest by entry time, exit time, duration, P\&L, or drawdown, or
filter to just longs or shorts.
Click any trade and it opens full-screen on a candlestick chart of the market
around it:
* **Entry and exit markers** are placed at the exact fill timestamps — not
snapped to the nearest bar — with dashed lines at your entry and exit prices,
so you can see precisely where each trade got in and out relative to the
price action.
* The header shows the trade's direction, its signed P\&L, and **why it
exited** — stop, target, trailing stop, session close, or signal, among
others — so you can check that your
[risk rules](/concepts/risk-and-trade-management) behaved the way you
intended.
* Each chart includes about **20 bars of context** before the entry and after
the exit, so you see the setup and the follow-through, not just the trade.
Hovering any bar shows its open, high, low, close, and volume.
* Use the **arrow keys** to step through trades one by one.
Pair this with the exit-reason breakdown in
[extended metrics](/guides/run-and-read-a-backtest#extended-metrics): if a
number there looks off (say, everything exits on session close), stepping
through a few of those trades on the chart usually shows you why.
## 2. Audit the exported data
For a deeper check, click **"Download trades with signal info"** on your
backtested strategy card. You get a CSV file — it opens directly in Excel or
Google Sheets — built so that every trade can be independently verified:
* **One row per trade**, straight from the simulator's trade log: entry and
exit timestamps, the filled prices *and* the raw source prices before tick
rounding, direction, and the exit reason (stop, target, trailing stop,
session close, signal, and so on), plus the stop and target levels that were
live on the trade.
* **P\&L, itemized.** Each row shows gross P\&L, the deducted costs (slippage
plus commissions, combined in one cost column), and net P\&L separately — so
you can recompute the result yourself from the prices and the contract's
tick value, by hand or with a formula.
* **The market state at entry, attached.** Each trade row is joined with the
strategy's computed indicator and signal columns from the latest available
bar *at or before the entry*. You don't just see that a trade happened — you
can compare the market state the strategy saw at entry against the rules you
described.
* **MAE and MFE** per trade, so you can sanity-check stop and target placement
against how trades actually behaved.
Because the engine is deterministic, the export always reconciles to the
headline metrics — the same rules, data, and simulation settings reproduce
the same results. See
[Exportable artifacts](/concepts/backtesting#exportable-artifacts).
## 3. The automated rules review
The step you never see is the one that matters most: making sure the rules
that get backtested are the strategy you actually described. After your
request is parsed into executable rules — and before anything is backtested —
an independent review pass audits the translation:
* Your request is first split into a ledger of **fragments — verbatim quotes
of your own words** (*"go long when the 20 EMA crosses above the 50"*,
*"stop at 10 ticks"*, …). The parser must declare which rule covers each
fragment.
* A **fresh review call** — with no memory of writing the rules, and not
allowed to edit them — then compares each quoted fragment against the actual
parsed rules: same signal, same data series, same direction, same level,
same units. It's given the contract's tick size and tick value so unit
conversions are checked arithmetically. A claim of coverage isn't accepted
as evidence — the reviewer verifies the rule really expresses your clause.
* Every fragment gets a verdict, and anything short of a faithful match — a
rule that says something different from your words, a clause that never made
it into the rules, or one written off as unsupported when it shouldn't have
been — automatically sends the strategy back to be re-parsed with the
specific problems spelled out.
* If a rule is still known to be wrong after that, **the strategy is not built
and nothing is backtested** — we'd rather stop than show you results for a
strategy you didn't ask for. Anything that couldn't be fully supported is
surfaced as an explicit caveat in the chat.
The review catches translation errors, not strategy design flaws. A
faithfully-translated bad idea still backtests badly — that's what the
numbers in [Run and read a backtest](/guides/run-and-read-a-backtest) are
for.
Backtest results are **hypothetical and simulated** — no real trades were
placed. Simulated results are designed with the benefit of hindsight and can
under- or over-state live outcomes. **Past performance does not guarantee
future results. Always test before you trade.**
## Next steps
Every chart and number a backtest produces, and how to read them.
Where the AI stops and the deterministic math begins.
Found something off? Change one rule and re-run.
How the simulation works, what's modeled, and the exportable artifacts.