Generate Trading Strategies Automatically

If you hear for the first time that trading strategies can be generated automatically, and that thousands of candidates appear within hours, you get suspicious. It sounds like a random generator with a nice interface. At the start of such a run there really is randomness, but that's only the first of several steps. By the end of this article you'll know how a run like this actually works in StrategyQuant X, why only a handful of strategies survive out of thousands, and what the survivors can tell you, and what they can't.

How the software builds new strategies in the first place

The Builder in StrategyQuant X knows two ways to build new strategies: random generation and genetic evolution. Neither way is better by default, you pick the mode before a run starts.

For a newly generated strategy, the Builder combines price patterns, technical indicators, order types and related building blocks into entry and exit rules. The result is at first just a validly assembled strategy, not automatically a sensible one.

How large the space of possible combinations is shows up in a number from the vendor's documentation: if you add up all the rules and their possible orders, you end up with trillions of mathematically possible strategies, and according to the vendor the software can generate and test thousands of new strategies per hour. That's an order of magnitude, not an exact count for any particular run, and it says nothing about how many of them turn out to be useful.

Why the sheer number says nothing about quality

Not every randomly generated strategy came out positive in the backtest, but among the thousands produced per hour, the vendor's documentation says many of them won more than they lost in testing. How many exactly depends on the building blocks you chose and the settings of the run, there's no fixed rate for this. And even if a strategy did well in the backtest, that only tells you something about the past, not the future.

That's exactly why the raw count isn't a quality measure. The fact that software can spit out thousands of candidates within an hour says nothing about how many of them end up being any good. The order of magnitude from the previous section measures the variety of the search space, not the quality of what comes out of it.

The first filter: automatic rejection rules

Because random generation can also produce nonsense, rules that contradict each other or make no economic sense, the Builder has automatic rejection rules. Depending on the settings, a large share, according to the documentation even the majority, of the generated strategies can get sorted out right here, before any evaluation by backtest metrics even happens.

These rules aren't some side effect you should switch off. They're the first of several filters that turn a huge, unsorted pile into something you can actually work with.

How a strategy run looks in practice

A typical workflow, described in the documentation as a blueprint, looks like this: import or download price data, configure the Builder, start the run, review the generated strategies, then retest, optimize or further refine the candidates that remain. That's a template, not a rigid rule, individual steps can be adapted to your own approach.

An example from the documentation shows this on EURUSD, with no predefined trading rules: first you choose the build mode, then you set up the price data and the split into in-sample and out-of-sample, then you pick the building blocks the Builder is allowed to use, and start the generation. The best results land in the run's database automatically. This example applies to exactly this configuration, other markets or timeframes don't necessarily need the same settings.

The second filter: robustness testing, and a sobering normal case

Getting past the rejection rules doesn't mean you're done. The vendor's documentation gives an example that surprises many people: it can easily happen that out of 1,000 strategies that came out positive in the first backtest, only a single one passes the stricter robustness tests and so even qualifies as a candidate for live trading. That's an example of the order of magnitude, not a fixed rate that applies to every run, and it says nothing about whether that one strategy is actually suited for live trading.

For most people working with automatic generation for the first time, this feels like a letdown. But it's the normal case, not a sign that something went wrong. That's exactly what the second filter is for.

What a green backtest doesn't promise

A backtest that looks positive is a statement about the past, not the future. Strategies optimized for a particular market environment tend to perform worse once conditions change. That explains why a strategy that ran well for a long time can suddenly start losing money, even though nothing in the code itself has changed. This behaviour can't be fully predicted or prevented, it's part of how market regimes work.

A second point concerns the What-If analysis: improvements you see there for one scenario can be due to chance, or turn out differently in live trading because trades influence each other. That's why the vendor recommends retesting a strategy with the adopted settings after every change, before you rely on it.

Why we teach exactly this process at QANTERIS

One reason many beginners fail with strategies they build themselves is that they don't know the difference between raw generation and a tested candidate. Course material on StrategyQuant X that covers this topic describes why most strategies built by beginners fail, how thousands of trading ideas can be generated and tested automatically, and how to build more robust strategies from there. That's why at QANTERIS we walk through this process step by step, instead of just explaining the surface.

What this method shows, and what it doesn't

Automatic generation and its filters show you how a strategy behaved on the historical data used for testing. They don't show you whether it will work the same way under future, unknown market conditions. That's not a weakness of the software, it's a limit of any method built on past price data, whether generated automatically or written by hand.

What's left at the end: a process that filters a huge pool of possible strategies down to a small number of candidates in several steps, each step doing its own job, without any of it telling you anything about future results.

This article is for education only and is not investment advice. Past results, including backtests, do not guarantee future results. Trading financial instruments involves risk, and you can lose money.