Somewhere along the way, patterns started to emerge. Not just in markets, but in how people think about them. The difference between guessing and testing. Between hoping and validating. Between noise and something that actually holds up.

That’s what I’ve been sharing.

Not signals. Not shortcuts. But the framework behind building something that can last.

If you’ve found value in what I’ve been writing, whether it helped you think differently, build something better, or just question your assumptions I’d really appreciate you following along more closely.

I write everything in one place now. Let’s connect on Substack!

👉 https://substack.com/@joshmalizzi

No fluff. Just real work, real ideas, and the occasional breakthrough.

– Josh

“Permutation and Randomization Tests for Trading System Development” by Timothy Masters is one of those books that helps us understand that most trading systems do not fail because markets are unknowable. They fail because we fool ourselves during development.

If you are building systematic strategies, especially with multiple signals, filters, or ensemble methods, this is not just an abstract idea.

It is the difference between something that looks great in a backtest and something that survives live trading.

This post focuses on one of the most practical concepts from the book: OHLC bar permutation testing, and why it is one of the cleanest ways to answer the only question that really matters. Will this system actually work going forward?

Keep reading on Substack:

https://open.substack.com/pub/joshmalizzi/p/ohlc-bar-permutation-how-to-confirm?utm_campaign=post-expanded-share&utm_medium=web

In Advances in Financial Machine Learning by Marcos López de Prado, de Prado describes ensembles as a combination of multiple models or classifiers whose outputs are aggregated to produce a single prediction, with the goal of improving robustness, reducing overfitting, and enhancing generalization.

In the book, ensembles are tightly tied to three core ideas:

1. Variance Reduction
Individual models are noisy and unstable. By combining many models, you reduce variance and smooth the output.

2. Generalization
A single model can overfit easily. Ensembles are designed to perform better out of sample by not relying on one specific fit.

Here is the link to the full article on Substack. I hope you enjoy!

What Is an Ensemble? Let's talk about it. (w/case study)

• Josh

I came across a question recently that seems simple on the surface, but it’s one of those questions that gets more interesting the longer you’ve been building systems:

“What are the core indicators we can use to build algorithms?”

Most people expect a shopping list in response. RSI. MACD. Bollinger Bands. Moving averages. Maybe a few exotic ones. If you’ve spent any time around trading forums, you’ve probably seen the same handful of indicators recycled endlessly, often with the implication that the right indicator is what separates winners from losers.

After years of actually building systematic strategies, generating large libraries of conditions, validating them out-of-sample, comparing them to randomness baselines, filtering by correlation, and then assembling ensembles, my answer is far less glamorous.

What matters is whether you can describe market behavior cleanly and consistently, then test it properly for its statistical properties. The indicators themselves are just a language for expressing those behaviors.

Before going any further, one important clarification: what follows is not meant to be comprehensive. This is not “the full list of everything that works.” It’s a starting point, a core foundation that has proven robust for me. There are many other useful features and indicators a trader can add on top of this depending on market, timeframe, and style. Think of this as the skeleton, not the entire body.

Below is the actual indicator language I use expressed the way it shows up in TradeStation logic — and why each category matters.

Time Is an Indicator (And It’s One of the Strongest Ones)

The most overlooked indicator in trading is time. Markets are shaped by settlement cycles, institutional flows, hedging behavior, rebalancing, and seasonality. None of that shows up as a moving average crossover but it absolutely shows up in performance if you test it properly. I treat time as a first-class signal input. That includes simple, explicit calendar logic like:

• Day of week
• DayOfWeek(date) = 1
• DayOfWeek(date) = 3
• DayOfWeek(date) = 5
• Grouped weekdays
• DayOfWeek(date) = 1 OR DayOfWeek(date) = 2
• DayOfWeek(date) = 3 OR DayOfWeek(date) = 4
• DayOfWeek(date) = 4 OR DayOfWeek(date) = 5
• Day of month
• DayOfMonth(date) <= 15
• DayOfMonth(date) >= 16
• DayOfMonth(date) >= 1 AND DayOfMonth(date) <= 10
• DayOfMonth(date) >= 21
• Month, quarter, half-year
• Month(date) = 1
• Month(date) = 12
• Month(date) <= 3
• Month(date) >= 7
• Other simple time structure
• DayOfYear(date) = 250
• WeekOfYear(date) = 42
• DayOfMonth(date) = 17

These kinds of time filters don’t predict direction. Their job is to slightly tilt the odds. On their own, they’re rarely impressive. Combined with other signal families, they often become stable contributors in a system.

Momentum & Mean Reversion: RSI as Pressure, Not a Signal

RSI is one of the most misunderstood indicators in retail trading. The problem isn’t RSI, it’s how narrowly it’s usually applied. I don’t treat RSI as an “overbought / oversold” switch. I treat it as a pressure gauge. What matters is where RSI is, where it was, and how it’s changing.

That shows up in logic like:

• RSI level states
• RSI(Close, 2) >= 70
• RSI(Close, 5) <= 30
• RSI(Close, 20) >= 50
• RSI relative comparisons
• RSI(Close, 2) > RSI(Close, 2)[5]
• RSI(Close, 10) < RSI(Close, 10)[10]
• RSI(Close, 20) <= RSI(Close, 20)[20]

Translation on the lower block:

RSI(2) of the current bar is greater than RSI(2) 5 bars ago

This is still just a starting point. There are many other momentum representations a trader can layer in, different oscillators, rate-of-change measures, or custom transforms, but RSI remains a simple, well-behaved building block when used this way.

Trend Strength (Not Trend Direction)

One of the most common reasons strategies fail is that they’re run in the wrong environment. Mean reversion ideas get destroyed in strong trends. Trend-following ideas get chopped up in sideways markets. That’s why I separate trend strength from trend direction. ADX is useful here, not as an entry trigger, but as a regime filter:

• ADX strength states
• ADX(10) > 25
• ADX(20) <= 20
• ADX(30) > 40

ADX is not the only way to do this, there are plenty of other regime and structure measures that work well but it’s a clean, interpretable starting point that integrates nicely with other signal families.

Raw Price Structure (Massively Underrated)

Some of the most durable signals don’t look like indicators at all. They’re simply statements about how price is behaving relative to itself.

For example:

• Open / High / Low / Close relationships
• Open > Open[5]
• Open <= High[10]
• Close > Low[20]
• Close <= Close[15]
• Prior-bar context
• Open[1] > Close[5]
• Open[1] <= Low[10]

These kinds of conditions are incredibly portable across markets. They don’t rely on smoothing assumptions or fragile parameters. They just ask whether price is behaving differently than it recently has. Again, this is not an exhaustive list but a representative slice of a broader family of price-structure ideas a trader can expand on.

Pivot & Reference Structure

Markets react to shared reference points. Not because those levels are mystical, but because many participants are looking at the same information. That shows up in logic like:

• Pivot comparisons
• (High + Low + Close) / 3 > ((High[5] + Low[5] + Close[5]) / 3)
• (High + Low + Close) / 3 <= ((High[10] + Low[10] + Close[10]) / 3)

There are many ways to define reference structure, pivots are just one clean starting example.

Trend Structure: Moving Averages as Environment

Moving averages still matter, just not as magic signals. I use them to define structure and regime:

• Short vs long structure
• Average(Close, 10) > Average(Close, 50)
• Average(Close, 20) < Average(Close, 100)
• Average(Close, 5) <= Average(Close, 40)

This isn’t the only way to define trend structure, but it’s a simple and effective starting point that plays well with other filters.

Volatility as a State Variable

Volatility is one of the most important contextual variables in systematic trading. Many strategies don’t actually fail, they’re just traded in the wrong volatility regime. I treat volatility relatively:

• Volatility expanding or contracting
• NATR[0] > NATR[10]
• NATR[5] <= NATR[20]

There are many other volatility representations a trader can explore, but relative volatility comparisons like this are often more robust than fixed thresholds.

Participation & Commitment: Volume and Open Interest

Volume and open interest rarely make great standalone entry signals. Where they shine is context. That shows up as simple structure logic:

• Volume comparisons
• Volume > Volume[10]
• Volume <= Average(Volume, 20)
• Open interest structure
• OpenInt > OpenInt[15]
• OpenInt < OpenInt[30]

Again, this is a foundation, not a limit. There are many additional participation-based features that can be layered in depending on market and data availability.

The Part Most People Miss

If you’re looking at this list and thinking, “That’s not that many indicators,” you’re right. That’s the point. This is not meant to be comprehensive. It’s meant to be a starting framework and a small, robust set of measurable behaviors that you can build on. There are countless other good features a trader can add once this foundation is in place.

The edge isn’t in discovering new indicators. It’s in expressing market behavior clearly, validating it properly, and then combining ideas intelligently.

Most indicators fail not because they’re bad ideas, but because they were:

• Over-optimized
• Traded in the wrong regime
• Highly correlated with other signals
• Indistinguishable from randomness when tested correctly

So when someone asks, “What are the core indicators for building algos?” my answer is simple:

Start with indicators that describe time, pressure, structure, volatility, and participation. Use them as a foundation, then expand thoughtfully from there.

The most important idea in this post is:

we should spend 10% of our time defining and creating indicators

we should spend 90% of our time testing indicators for statistical robustness

Hope this helps.

— Josh

Most traders spend their time obsessing over individual systems. The perfect entry. The perfect indicator. The one setup that “finally works.” But professional traders, the ones who survive decades, not months, obsess over something very different:

Portfolios.

Not because individual systems don’t matter.
But because portfolios change the math of risk itself.

In this post, I want to show you something real. No theory. No hypothetical correlations. Before we look at a single metric, let’s remove the usual escape hatches. Everything in this analysis is done using one contract per futures symbol.

No leverage.
No volatility targeting.
No position scaling.
No capital tricks.

We will use 20 real trading systems, 20 U.S. futures markets, all long-only, actual historical PnL in dollars. Each system trades a single U.S. futures market, long-only, with real historical trades and real dollar PnL. The only thing we change throughout this study is how many systems are combined into a portfolio. Remember there is NO reinvesting / compounding happening here which is a big way to boost profitability.

This constraint matters, because it forces us to confront a reality that many traders prefer to avoid:

The biggest improvements in trading performance often come without better systems. They come from portfolios.

And we’ll answer one simple question:

What happens to risk when you stop trading systems and start trading portfolios?

The Setup: 20 Ordinary Trading Systems

We begin with twenty independent trading systems, each tied to a different U.S. futures symbol. They were not designed together. They were not optimized to interact. They simply exist.

Each system produces a stream of trades, which were converted into daily PnL series, aligned on a common business-day calendar. Individually, these systems are not exciting. They are boring.

They make money, but slowly.
They draw down, sometimes deeply.
They would test anyone’s patience.

And that’s the point. Because this is what real systems look like.

Quick but Important: What These Metrics Actually Mean

Before listing numbers, it’s worth briefly grounding what each metric measures and why it matters.

Sharpe Ratio

The Sharpe ratio measures how much return you earn per unit of volatility. In plain language, it answers how smooth is the ride relative to the reward? Importantly, Sharpe does not measure raw profitability. It measures risk-adjusted efficiency. Sharpe is also scale-invariant meaning it doesn’t care how big your PnL is, only how noisy it is.

A Sharpe of:

• 0.5 is noisy and difficult to trade
• 1.0 is respectable
• 2.0 is professional
• 3.0 is rare without leverage or overfitting

Profit Factor

Profit factor is the ratio of total profits to total losses. A profit factor of 1.5 means you make $1.50 for every $1.00 lost. It tells you how forgiving a system is when it’s wrong.

Drawdown

Drawdown is the peak-to-trough loss in equity. This is not an academic metric. Drawdown is where traders quit, funds close, and careers end. Reducing drawdown is not cosmetic, it is survival.

CAGR

CAGR (compound annual growth rate) measures how efficiently capital grows over time. It is deeply influenced by drawdowns. Two strategies with the same returns can have wildly different CAGRs if one experiences deeper losses.

PnL

Total PnL tells us something simple but often ignored: if I add up all wins and losses, how much do I have? If risk goes down but returns vanish, the portfolio has failed. With that context, let’s look at what actually happens.

Individual Systems: Adequate, Not Impressive

On their own, the systems are all generally similar. The representative single-system Sharpe is ~0.82, with most systems living between 0.8 and 1.1. Profit factors hover around 1.4–1.5. Drawdowns are uncomfortable. Growth is slow. This is the reality most traders face when they stop optimizing and start trading. And it’s exactly why portfolios matter.

Sharpe Ratio: How Structure Changes the Math

Let’s now combine systems incrementally and examine the Sharpe ratio at every step. Remember: nothing about the systems changes. Only the number of systems held simultaneously. Here are the annualized Sharpe ratios from 1 through 20 systems as they are combined into larger and larger portfolios:

1 system: 0.82
2 systems: 1.07
3 systems: 1.26
4 systems: 1.39
5 systems: 1.48
6 systems: 1.59
7 systems: 1.70
8 systems: 1.83
9 systems: 1.99
10 systems: 2.07
11 systems: 2.26
12 systems: 2.35
13 systems: 2.40
14 systems: 2.46
15 systems: 2.56
16 systems: 2.49
17 systems: 2.57
18 systems: 2.66
19 systems: 2.71
20 systems: 2.77

No reweighting. No filtering. Just equal-weight combination. This is not optimization. This is arithmetic. From one system to twenty, Sharpe improves by over 230%. The portfolio crosses into professional-grade territory long before we reach the full set. This is why institutions build portfolios instead of chasing better indicators. We took a collection of ordinary systems and created a professional-grade portfolio. No new indicators, logic, parameter tweaks, just combination.

Profit Factor: Efficiency Improves Quietly

Sharpe isn’t the only thing improving. Profit factor also improves consistently. Here is the profit factor at each portfolio size:

1 system: 1.45
2 systems: 1.44
3 systems: 1.46
4 systems: 1.47
5 systems: 1.52
6 systems: 1.59
7 systems: 1.61
8 systems: 1.64
9 systems: 1.67
10 systems: 1.69
11 systems: 1.72
12 systems: 1.74
13 systems: 1.76
14 systems: 1.78
15 systems: 1.79
16 systems: 1.72
17 systems: 1.75
18 systems: 1.76
19 systems: 1.78
20 systems: 1.79

That’s a +23% improvement in profit factor while taking less risk. This happens because losses stop clustering in time. This matters because it shows that diversification is not just smoothing returns, it is reducing loss overlap. Losses occur less simultaneously, making the portfolio structurally more efficient. We are seeing that diversification improves both return efficiency and loss control.

Drawdown: Where Portfolios Earn Their Keep

Now to the most important metric. Maximum dollar drawdown at each step:

1 system: -$6,980
2 systems: -$5,709
3 systems: -$4,614
4 systems: -$3,606
5 systems: -$3,091
6 systems: -$3,405
7 systems: -$3,251
8 systems: -$3,507
9 systems: -$3,346
10 systems: -$3,499
11 systems: -$3,214
12 systems: -$3,096
13 systems: -$3,021
14 systems: -$2,987
15 systems: -$3,104
16 systems: -$4,210
17 systems: -$3,974
18 systems: -$3,529
19 systems: -$3,344
20 systems: -$3,300

Despite some noise, the pattern is unmistakable: The portfolio cuts drawdown roughly in half without reducing participation. This is the difference between abandoning a strategy and surviving long enough for it to work. This is the part that keeps traders alive.

PnL: Diversification Does Not Kill Returns

A common fear is that diversification “waters down” profits. The total PnL tells a different story. The 20-system portfolio generates over $126,000 in cumulative PnL trading one contract per market where the average PNL of the contributing systems was $72,000. This is a 75% increase in PNL which is material. What we see here is:

Risk goes down. Returns remain.

That combination is rare outside of portfolios.

CAGR: Growth Through Risk Control

Because drawdowns shrink and equity curves smooth out, CAGR improves steadily as systems are added. System 1 alone resulted in 11.8% CAGR where the 20 system portfolio results in 18.1% CAGR. This is a 53% increase on a no-reinvestment basis.

This is not because the portfolio suddenly becomes aggressive. It’s because capital spends less time recovering from losses. Lower drawdowns mean faster recovery. Faster recovery means better compounding. This is how professional portfolios grow quietly for decades.

The Final Portfolio: 20 Systems, One Contract Each

Let’s summarize the full 20-system portfolio:

• Sharpe ratio: ~2.77
• Profit factor: ~1.79
• Maximum drawdown: ~$3,300
• Active exposure: ~94% of days
• CAGR: 18.1%

So the portfolio produces roughly:

~1.8–2.3 units of return for every 1 unit of drawdown

This is extremely strong risk efficiency.

S&P 500 (Historical Context)

Now compare that to the S&P 500:

• CAGR: ~9–10%
• Maximum drawdown: ~50–55%

That yields:

• Return / DD:
  9 ÷ 55 ≈ 0.16
  10 ÷ 50 ≈ 0.20

So the S&P produces roughly:

~0.16–0.20 units of return for every 1 unit of drawdown

Side-by-Side Comparison

• 20-system portfolio: ~1.8–2.3
• S&P 500: ~0.16–0.20

That means the portfolio is approximately 9–14× more efficient than the S&P 500.

Why This Works (Even When Everything Is Long)

All systems are long. And yet, risk collapses. Why? Because correlation is not direction — it’s timing. Markets move differently. They trend differently. They mean-revert differently. They respond to stress differently. Perfect correlation is rare. And portfolios only need imperfect independence to work.

The Core Lesson

This entire study can be summarized in one sentence:

Portfolios turn average systems into professional-grade strategies.

You do not need brilliance.
You do not need perfection.

You need many small edges and the discipline to let structure do the heavy lifting.

That is the quiet superpower of trading.

And it’s hiding in plain sight.

• Josh

If you’ve enjoyed my posts here on Medium, feel free to connect with me there as well. I’ll be sharing short notes, longer explanations, and ongoing ideas in a more conversational format.

You can find me here:

👉 https://substack.com/@joshmalizzi?invite

Totally optional — just another place to follow along.

— Josh

One of the hardest problems in systematic trading is not finding strategies that make money in a backtest.

It is figuring out whether they did anything special at all.

If you test enough ideas, some of them will look good purely by chance. That is not a flaw in your research process. It is a property of randomness. The problem starts when we mistake those lucky outcomes for real edge.

Monte Carlo (MC) returns are one of the few tools that help address this directly. But only if they are used correctly.

This article explains how I use Monte Carlo returns matched to a strategy’s trade count to answer a very specific question:

Is this strategy meaningfully better than what random participation in the same market would have produced, given the same number of trades?

That last clause matters more than most people realize.

The Core Problem: Strategy Returns Without Context

Suppose a strategy produces:

• +0.12 normalized return per trade
• Over 300 trades
• With a smooth equity curve

Is that good?

The honest answer is: it depends.

It depends on:

• The distribution of returns in the underlying market
• The volatility regime
• The number of trades taken
• The degree of path dependence
• How much randomness alone could have achieved

Without a baseline, strategy returns are just numbers.

Monte Carlo returns provide that baseline, but only when they are constructed in a way that respects sample size.

Why “Random Returns” Are Often Done Wrong

Most MC implementations I see fall into one of these traps:

1. Comparing a strategy to random trades with a different number of trades
2. Comparing to random returns aggregated over the full dataset
3. Using non-deterministic MC that changes every run
4. Using unrealistic return assumptions such as Gaussian noise or shuffled bars

That is where the pick method comes in.

What the Pick Method Actually Does

At a high level, the pick method answers this:

If I randomly selected the same number of return observations as my strategy trades, many times, what does the distribution of outcomes look like?

Instead of simulating trades with their own logic, we:

• Take the actual historical return stream of the market
• Randomly pick N returns from it
• Aggregate them using the same statistic the strategy is judged on
• Repeat this thousands of times
• Measure where the strategy sits relative to that distribution

This gives us a fair baseline.

If a strategy trades 312 times, we compare it to random samples of 312 market returns. Not more. Not fewer.

That alignment is critical.

Why Sample Size Is the Entire Game

A strategy that trades 50 times can look spectacular.

A strategy that trades 1,000 times rarely does.

That is not because the first strategy is better. It is because variance dominates small samples.

Monte Carlo benchmarking with matched sample size does two things simultaneously:

1. It controls for luck
2. It reveals whether performance improves faster than randomness as sample size increases

This is why MC results should be computed across a wide range of pick sizes, not just one.

In my implementation, this is exactly what happens:

• Picks range from 2 to 2000
• Each pick size gets its own MC baseline
• Strategy performance is compared to the corresponding pick level

That turns MC from a single reference number into a curve, which is far more informative.

Deterministic Monte Carlo: An Underrated Requirement

Most people do not think about this, but it matters enormously.

If your Monte Carlo baseline changes every time you run it, your research is unstable.

Non-deterministic MC introduces noise into the benchmark itself. That makes it hard to know whether:

• A strategy changed
• Or the benchmark moved

Your deterministic approach fixes this by:

• Using a fixed root seed
• Deriving child random generators using hashed keys
• Ensuring the same inputs always produce the same MC outputs

This has several benefits:

• Results are reproducible
• Research decisions are consistent
• Changes in conclusions reflect changes in strategies, not random drift
• MC results can be cached and reused safely

This is especially important when MC returns are used as filters in a large research pipeline.

What Is Actually Being Sampled

In your setup, Monte Carlo draws from:

• The in-sample normalized returns of the underlying market
• After removing NaNs
• Using the same return definition used by strategies

That is important.

You are not sampling synthetic noise.
You are sampling real market outcomes, just without strategy timing.

This answers a very specific question:

If I had participated in this market randomly, with no signal, but the same number of opportunities, what would I expect?

That is the right null hypothesis.

Mean vs Sum vs Element Quantile

Your MC function allows multiple statistics. Each answers a slightly different question.

Mean

• Computes the average return per trade
• Directly comparable to strategy mean return
• Stable and intuitive
• Scales cleanly across sample sizes

This is the most appropriate comparison when your strategy metric is average normalized return per trade.

Sum

• Emphasizes total outcome
• More sensitive to trade count
• Useful when comparing total PnL distributions

Element quantile

• Looks inside each sample
• Focuses on tail behavior
• Useful in specific cases, but harder to interpret

Using mean keeps the comparison clean and avoids conflating edge with frequency.

Building the MC Return Surface

Rather than producing a single MC number, your implementation builds a surface:

• Rows equal pick size multiplied by quantile
• Columns equal return definitions
• Cells equal MC benchmark values

This lets you answer questions like:

• What does the median random outcome look like at 200 trades?
• What about the 80th percentile?
• How fast does random performance improve with sample size?
• Where does my strategy sit relative to these curves?

This is much richer than a pass or fail test.

Why Quantiles Matter

Comparing a strategy to the median MC outcome answers:

Is this better than random, on average?

Comparing to higher quantiles answers:

Is this better than good randomness?

For example:

• Beating the 50th percentile means better than average luck
• Beating the 75th percentile means better than most random outcomes
• Beating the 90th percentile means very unlikely to be luck

This is far more informative than a binary p-value.

How This Changes Strategy Evaluation

Once MC returns are available, strategy evaluation changes fundamentally.

Instead of asking:
Is the mean return positive?

You ask:
Where does this strategy sit relative to random baselines with the same trade count?

That reframes performance as relative skill, not absolute outcome.

A strategy with modest returns but far above MC baselines is often more interesting than a high-return strategy barely above random.

Using MC Returns as a Filter

In a large signal-mining framework, MC returns become a gate, not a report.

For example:

• Reject any signal whose mean return does not exceed the MC median at its trade count
• Or require it to beat the MC 60th or 70th percentile
• Or require separation that grows with sample size

This filters out strategies that only look good because they got lucky early.

That is exactly what you want when mining thousands of candidates.

Why This Is Better Than Shuffling Trades

Trade shuffling is common, but it often answers the wrong question.

Shuffling strategy trades tests whether ordering mattered.

Monte Carlo picking tests whether selection mattered.

For signal evaluation, selection is usually the more relevant concern.

You are asking:
Did the signal meaningfully select better returns than chance?

Not:
Did the order of trades help?

Both are valid questions, but MC picking directly addresses edge discovery.

A Concrete Example

Imagine:

• A strategy trades 400 times
• Mean normalized return equals 0.08

Monte Carlo results show:

• MC median at 400 trades equals 0.02
• MC 75th percentile equals 0.05
• MC 90th percentile equals 0.09

This tells you something important:

• The strategy beats most random outcomes
• But it is not exceptional relative to the best random cases
• The edge may be real, but thin
• It deserves caution, not celebration

Without MC returns, that nuance is invisible.

Why This Matters for Capital Allocation

Capital allocators do not care whether a strategy made money once.

They care whether:

• The process extracts information
• The edge exceeds what randomness could plausibly explain
• The advantage grows with sample size
• The result is reproducible

MC returns aligned to trade count speak directly to that.

They show:

• How much of performance is skill versus chance
• Whether the strategy earns its returns
• How confident one should be in scaling it

The Bigger Picture: MC as Part of a System

Monte Carlo returns do not replace:

• Out-of-sample testing
• Walk-forward analysis
• Regime slicing
• Correlation filtering

They complement them.

MC answers the question:
Is this signal better than random participation, given the same opportunity set?

That is a foundational test. If a strategy cannot pass it, nothing else matters.

Final Thoughts

Monte Carlo returns are not about prediction.

They are about humility.

They force you to confront the uncomfortable truth that:

• Many strategies look good because they were lucky
• Sample size matters more than cleverness
• Real edges should separate from randomness consistently

By using deterministic MC returns matched to strategy trade counts via the pick method, you turn randomness into a measurable benchmark rather than a hidden confounder.

That is not just better research.

It is more honest research.

One of the biggest shifts in my research over the last few years wasn’t a new indicator or a clever entry rule.

It was a mindset change:

Instead of asking, “Can I predict this market?”
I started asking, “What are other markets already telling me?”

That’s a very different frame.

Most traders treat markets as separate worlds:

• Crude oil has its own story.
• The dollar has its own story.
• Bonds have their own story.
• Equities have their own story.

But when you’ve watched markets long enough, you start seeing the connectivity:

• Rates influence equities.
• The dollar influences commodities.
• Risk-off shows up in bonds before it shows up elsewhere.
• Volatility regimes ripple across everything.

So rather than building a strategy that only looks inward (price-based features from the traded market), I started using a wide market view — a fixed set of signals, applied across 35 futures markets, and tested as inputs to trading decisions.

This article is about that approach:

• Why using other markets as signals can be a durable edge
• Why I intentionally start with an absurd number of signals (50,000+)
• How I generate them mechanically (and why “mechanical” matters)
• And how this becomes a data-mining problem that can be handled responsibly

The 35-Market Signal Universe

Here’s the market list I’m using as a feature set, not necessarily what I’m trading, but what I’m listening to and deriving signal from:

AD_F, BO_F, BP_F, CO_F, CD_F, CL_F, EC_F, ES_F, FC_F, FV_F, GC_F, HG_F, HO_F, JY_F, KW_F, LC_F, LH_F, NG_F, NK_F, NQ_F, OA_F, PL_F, RB_F, RR_F, RT_F, SO_F, SF_F, SI_F, SM_F, TU_F, TY_F, US_F, WH_F, YM_F, VX_F

This is a deliberately mixed basket:

• Equity index risk: ES, NQ, YM, NK
• Rates (risk-free / macro gravity): TU, FV, TY, US
• Volatility regime: VX
• FX: AD, BP, CD, EC, JY, SF
• Energy: CL, HO, RB, NG
• Metals: GC, SI, HG, PL
• Grains / softs: CO, WH, KW, OA, SO, SM, BO, RR
• Livestock: LC, FC, LH
• Rates-sensitive and growth-sensitive proxies show up everywhere in this set

The point isn’t diversification for trading. The point is diversity for information.

In other words:

I’m not building a multi-market strategy first.
I’m building a multi-market sensor array.

Why Other Markets Make Great Signals

If you trade one market long enough, you learn this the hard way:

• Your market often moves for reasons outside itself.
• Some of the best “explanations” for today’s move are not inside today’s candle pattern.
• Regimes shift first — and price patterns change second.

Other markets help because they often carry:

1. Causal information (rates, dollar, energy inputs, risk appetite)
2. Regime information (volatility, liquidity, macro stress)
3. Positioning information indirectly (open interest, volume behaviors)
4. Cross-asset confirmation (risk-on vs risk-off alignment)

A simple example:

• If equities are grinding higher, volatility is collapsing, and bonds are rallying aggressively… that’s a very different environment than equities rising while volatility is rising and bonds are selling off.

Same “equities up” headline. Totally different regime under the hood.

That regime distinction often matters more than the signal itself.

So the thesis is not “intermarket prediction is magic.”

It’s more modest:

Other markets can help identify the environment your target market is currently trading inside.

And that’s exactly where a lot of systematic edge lives.

The Key Design Choice: One Signal Library Applied Everywhere

The core idea in your code is simple, but powerful:

• Define a library of generic, reusable, mechanical signals
• Apply that same library to each of the 35 markets
• Evaluate each resulting binary condition as a candidate predictor (or regime filter)

This matters because it forces discipline.

If you write custom signals per market, you accidentally embed:

• market-specific assumptions
• narrative bias (“gold should do X when inflation is Y”)
• degrees of freedom that explode the search space

But if you use the same signal grammar everywhere, you get:

• consistency
• comparability
• a cleaner statistical problem

It becomes closer to:
“Which markets contain useful state information?”
instead of:
“Which handcrafted rules feel right?”

Why I Start With 50,000+ Signals (On Purpose)

People hear “50,000 signals” and assume I’m trying to brute-force my way into an edge.

That’s not the point.

The point is to treat signals as hypotheses, not as beliefs.

When you generate signals programmatically, you’re doing something like this:

• RSI(2) >= 70
• RSI(20) <= 25
• MA(10) > MA(50)
• Volume[0] > Volume[10]
• Close[0] > Highest(High, 20)
• NATR[0] < NATR[10]
• Open interest rising vs falling

None of these are “the strategy.”

They are candidate descriptors of market state.

And if you run them across 35 markets, you’re no longer asking:

“Does RSI work?”

You’re asking:

“Does a short-term momentum extreme in any specific market reliably precede better outcomes in my target market?”

That’s a different question.

The Signal Generator: A Mechanical Grammar of Market Conditions

Your get_main_signals() function is essentially a DSL (domain-specific language) for hypothesis creation.

It builds a list of condition pairs:

• EasyLanguage string (for TradeStation deployment)
• Python/TA-Lib string (for research/testing)

This is critical if you actually care about production:

The research rules are the deployable rules.

No “research-only” logic. No “we’ll translate later.”
Same signal, same meaning, across environments.

What’s inside this grammar?

1) RSI thresholds

You generate RSI across multiple windows:

• 2, 5, 10, 20, 30, 40, 50, 60

And thresholds from 0 to 95 in steps of 5:

• RSI >= i
• RSI <= i

That’s already a large hypothesis set. And it’s not about finding “the right RSI level.”

It’s about discovering:

• which regimes (oversold/overbought / compression / drift) matter
• and in which market they matter

2) RSI momentum / change over time

You compare RSI today vs RSI shifted:

• RSI(t) > RSI(t — k)
• RSI(t) <= RSI(t — k)

That turns RSI from a static oscillator into a state-transition signal:

• improving momentum vs deteriorating momentum

3) Pivot point comparisons

You use:

• (H + L + C) / 3

And compare the pivot to prior pivots:

• pivot[t] > pivot[t-k]
• pivot[t] <= pivot[t-k]

This tends to capture directional drift in a way that’s different than MA.

4) Raw OHLC comparisons

You generate a grid of:

• open/high/low/close compared to prior bars

Both for bar 0 and bar 1 in several blocks.

This matters because these features often capture:

• gap behavior
• momentum continuation
• mean reversion tendencies
• “where did we open relative to recent structure?”

And they’re extremely cheap to compute and robust across markets.

5) ADX thresholds

You generate ADX thresholds across multiple windows:

• 2, 5, 10, 20, 30, 40, 50, 60
• with thresholds 5..95

This creates hypotheses around:

• trend strength regimes
• low-trend chop vs strong directional state

6) Moving average relationships

You generate MA cross relationships using loops:

• short MA: 5..195 step 5
• long MA: 5..185 step 20
• only short < long
• generate both “short > long” and “short < long”

This is a cleaner way to build MA signals than dozens of handpicked crossovers.

It’s systematic and bounded.

7) Volatility regime via NATR relationships

Rather than thresholds (“NATR > 1.2”), you do comparisons:

• NATR[start] > NATR[end]
• NATR[start] < NATR[end]

That matters: it’s often the direction of volatility change that matters more than the absolute level.

This gives you “volatility rising” and “volatility falling” hypotheses without needing to guess a fixed cutoff.

8) Volume and volume vs rolling mean

Same pattern:

• volume comparisons across time
• volume relative to rolling averages

Volume is one of those features that often matters more intermarket than within a single market. It can represent:

• participation
• urgency
• stress / liquidation
• regime transition

9) Open interest regime changes

You generate:

• OI[start] > OI[end]
• OI[start] < OI[end]

Open interest is a major tell in futures, but it’s not easy to interpret narratively.

Your approach turns it into something testable:

• “OI expanding”
• “OI contracting”

Across markets, OI shifts often reflect global positioning changes which can matter for a target market even if the target market’s own OI looks normal.

10) Breakout structure: close vs highest high / lowest low

These signals detect:

• breakout states
• compression → expansion
• structural level violations

And you generate them in a systematic grid.

Why This Works as a “Large Market View”

When you run this signal library across 35 markets, you’re doing something like:

“Build a standardized set of sensors for each market, then ask which sensors predict better future outcomes in my target market.”

This is the same reason macro trading desks watch:

• rates
• dollar
• credit spreads
• volatility

They’re not trading those instruments necessarily. They’re using them to understand the environment.

Your approach formalizes that into binary features.

It’s macro awareness without narrative.

The Big Risk: Data Mining and False Discovery

Let’s be honest: 50,000 signals is a false discovery factory if you don’t control for it.

If you test enough hypotheses, you will find “statistically significant” results by chance.

That doesn’t mean the approach is wrong — it means the validation has to be real.

This is where your broader pipeline matters:

• normalized returns
• P-tests
• bootstrapping
• superiority tests
• trade count thresholds
• correlation thinning
• out-of-sample validation
• Monte Carlo tests
• Randomized tests

That’s how you turn “search” into “research.”

The signal generator creates the hypothesis space.
The validation framework is what prevents self-deception.

Why This Approach Can Produce More Durable Edges

A single-market technical strategy often fails because it’s too close to the noise source.

But intermarket signals often reflect:

• slower-moving capital flows
• macro regime shifts
• policy cycles
• risk-on / risk-off transitions
• inflation / growth expectations

Those forces are not perfectly arbitraged away because they don’t express themselves in one instrument cleanly.

They express themselves across the network.

So if you can quantify the network state even crudely you often get signals that are more robust than a clever pattern inside one chart.

Practical Examples (How to Think About It)

Here are a few conceptual examples of what this framework can discover:

• Rates regime as filter: certain equity signals only work when TY/US is trending down (risk-on rates regime)
• Dollar regime as filter: commodity systems change behavior depending on EC/JY/SF momentum
• Volatility regime: many strategies work during VX compression and fail during VX expansion
• Energy input impacts: HO/RB/CL regime shifts often precede broader inflation expectations affecting multiple markets
• Cross-asset confirmation: if ES is breaking out but GC is also breaking out while the dollar is rallying… that’s not the same “breakout” environment

You don’t need to believe any narrative upfront.

You let the testing tell you which relationships are stable.

Closing Thought: This Is How You Avoid Being “Single-Market Blind”

If you only study one market, you end up overfitting to that market’s historical quirks.

A broad market feature set forces you to confront something bigger:

your target market is a node in a network.

This approach , 35 markets, one standardized signal grammar, 50,000 testable hypotheses , is not about finding the “perfect indicator.”

It’s about building a consistent way to measure the market environment from multiple angles, then letting rigorous validation decide what’s real.

That’s the difference between data mining and systematic research.

Most trading systems fail not because their individual signals are bad, but because the way those signals are combined is naïve.

Researchers spend years discovering indicators, filters, and conditions with genuine edge, only to destroy that edge by averaging everything together or over-optimizing a single composite rule. The result is a brittle system that looks impressive in-sample and collapses when market conditions change.

This article describes a different approach:
a hierarchical ensemble architecture built on behavioral grouping, majority voting, and successive meta-filters.

The philosophy is simple:

Let signals vote within environments they understand, then let environments vote on the market, and finally apply light-touch meta rules to remove obvious mistakes.

The result is not a single “perfect” strategy, but a self-auditing decision system that becomes more selective as confidence increases.

The Core Idea: Layered Consensus, Not Optimization

At the heart of this framework is a rejection of monolithic signal design.

Instead of asking:

“What single rule should I trade?”

the system asks:

“When many independent perspectives agree, is that agreement meaningful — and can it be improved safely?”

This leads to three structural layers:

1. Signal → Group consensus (within behavioral regimes)
2. Group → Master consensus (across regimes)
3. Meta-filters that gate decisions without rewriting them

Each layer reduces noise, controls overfitting, and increases interpretability.

Step 1: Behavioral Groups as Independent Voting Bodies

Before any voting occurs, signals are already partitioned into behavioral groups — for example:

• Volatility-positive, market-negative
• Volatility-positive, market-neutral
• Volatility-negative, market-positive
• …and so on

Each group contains signals that are structurally aligned with the same market conditions. This is critical.

Signals are not voting against unrelated signals. They are voting among peers that “see” the market in similar ways.

Think of each group as a specialized committee.

Step 2: Majority Voting Inside Each Group

Within each group, signals are binary: on or off.

At every bar, the system counts how many signals in the group are active and compares that count to a group-specific voting threshold.

If enough signals agree, the group emits a trade signal.

Importantly, this threshold is not universal.

Some environments are noisy and require stronger consensus. Others are sparse and benefit from lower thresholds. Each group has its own required percentage of agreement.

This accomplishes several things simultaneously:

• Reduces reliance on any single signal
• Dampens noise from unstable indicators
• Preserves diversity of logic within a regime

The group signal becomes a probabilistic statement, not a deterministic rule:

“Enough signals aligned with this market behavior believe a trade is justified.”

This is a meaningful improvement over naïve averaging.

Why Majority Voting Works Better Than Weighting

Many systems attempt to weight signals by Sharpe ratio or past performance. This often backfires.

Weights are fragile. They encode historical noise and decay quickly.

Majority voting is deliberately blunt:

• It ignores magnitude
• It ignores parameter tuning
• It only asks: how many agree?

This makes it remarkably robust.

In practice, majority voting behaves like a non-parametric filter. Signals either support the trade or they don’t. The ensemble adapts naturally as individual signals drift in and out of relevance.

Step 3: Group-Level Returns and Accountability

Each group’s signal is converted into a return stream and tracked independently.

This is not just for performance — it’s for auditability.

At any point, you can ask:

• Which groups are contributing?
• Which environments are active?
• Which groups are dormant or harmful?

This transparency matters enormously in live trading. When drawdowns occur, you are not blind. You can see which types of market logic are failing.

Step 4: The Master Ensemble — Groups Vote on the Market

Once each group has produced a signal, the system moves up one level.

Now, groups vote instead of signals.

At each bar, the system counts how many behavioral groups are active and compares that to a master threshold.

If enough groups agree, the master system trades.

This is a crucial conceptual shift.

The master system is not asking:

“Do many signals agree?”

It is asking:

“Do multiple, distinct market perspectives agree?”

This dramatically reduces false positives.

Random alignment within one regime is common. Alignment across multiple regimes is rare — and meaningful.

Why This Reduces Overfitting

Overfitting thrives on specificity.

The more narrowly defined a rule becomes, the more likely it is to fit noise.

This architecture does the opposite:

• Signals are coarse (binary)
• Voting is discrete
• Thresholds are simple
• No parameters are optimized jointly

Each layer adds selectivity without adding degrees of freedom.

That is the key.

Step 5: Meta-Filtering — Improving Decisions Without Rewriting Them

After the master ensemble is built, the system applies meta-rules — lightweight gates that sit on top of existing signals.

A meta-rule does not create new trades.
It can only veto or confirm existing ones.

This distinction is vital.

Meta-rules are evaluated by asking:

“If I require this additional condition, does the system improve without destroying trade frequency?”

The process is conservative by design:

• A minimum number of in-sample trades is required
• A minimum fraction of base trades must be preserved
• The scoring metric is fixed (e.g., Profit Factor or Sharpe)

Only the best single meta rule is selected at each layer — or none at all.

If no rule improves the system safely, the base signal is left untouched.

This is how restraint is enforced programmatically.

Meta-1: Improving Each Group Independently

The first meta layer operates within each behavioral group.

Each group’s ensemble signal is evaluated against a library of candidate filters. The best filter — if one exists — is applied only to that group.

This allows, for example:

• A volatility-positive group to add a volatility-confirmation gate
• A trend-positive group to add a regime-confirmation filter

Crucially, different groups can select different meta rules.

There is no assumption that one filter fits all environments.

Measuring Lift, Not Just Performance

After Meta-1 is applied, the system explicitly compares:

• Base group vs. Meta-filtered group
• Across IS, OOS, and multiple OOS segments
• Using trade count, Sharpe, Profit Factor, mean, and variance

The goal is not just improvement, but controlled improvement.

If Sharpe rises but trade count collapses, the meta rule is suspect.
If PF improves modestly while structure remains intact, it’s a win.

This comparison is logged, saved, and auditable.

Step 6: Meta-Ensembling — Groups Vote Again, Post-Filtering

After Meta-1 is applied to each group, the system rebuilds the master ensemble using the filtered group signals.

This creates a second-generation master system:

• Same voting logic
• Cleaner inputs
• Fewer low-quality trades

Importantly, the master voting threshold remains simple. No re-optimization is performed.

The system’s intelligence comes from structure, not parameter tuning.

Meta-2 and Meta-3: Progressive Skepticism

The architecture allows for additional meta layers.

Each layer applies the same conservative logic:

• Require sufficient trade count
• Preserve most of the base behavior
• Score using a fixed metric

Meta-2 might optimize for overall profitability.
Meta-3 might optimize for risk-adjusted returns.

At each step, the system becomes more selective — but only if justified.

If no improvement is found, the system stops changing.

This is the opposite of curve-fitting. It is iterative skepticism.

Why This Framework Is Robust

This method works because it aligns with how markets actually behave:

• Markets shift regimes
• Signals have conditional edge
• Consensus matters more than precision
• Overconfidence is the real enemy

The system does not pretend to predict regimes.
It ensures coverage across them.

It does not seek perfect signals.
It seeks agreement among imperfect ones.

And it does not blindly optimize.
It filters cautiously, one layer at a time.

A Mental Model: Committees, Not Dictators

A useful analogy is governance.

Signals are citizens.
Groups are committees.
The master system is a council.
Meta rules are veto powers.

No single entity controls outcomes.
Consensus builds gradually.
Bad ideas struggle to survive multiple layers.

This is not accidental. It is the entire point.

Final Thoughts

Most systematic trading failures come from excessive confidence in fragile logic.

This framework replaces confidence with process.

Every decision must survive:

• Signal-level disagreement
• Regime-level disagreement
• System-level disagreement
• Meta-level skepticism

What remains is not perfect — but it is honest.

And in markets, honesty about uncertainty is often the greatest edge of all.

Most trading systems fail for a simple reason:
they assume one signal should work in all markets.

Markets do not behave that way.

Trends emerge, collapse, reverse, stall, and fracture across regimes of volatility, sentiment, and participation. Yet most signal research implicitly treats performance as unconditional — averaged across all environments — and then discards signals that “don’t work well enough.”

A more productive question says something very different:

Under what market conditions does this signal actually work?

Once you ask that question, a powerful framework emerges:
slice signals into behavioral buckets, then ensemble them across regimes.

From “Does It Work?” to “When Does It Work?”

Traditional signal evaluation focuses on aggregate statistics:

• Average return
• Sharpe ratio
• Profit factor

These metrics implicitly assume that signal behavior is stable across time. In reality, many signals are conditional:

• Some thrive in rising markets
• Some profit from volatility expansion
• Some fade trends
• Some exploit skewed outcomes

When evaluated in aggregate, these signals often look mediocre — not because they lack edge, but because their edge is situational.

The goal of regime slicing is not to find the “best” signal, but to map signals to the environments they are naturally aligned with.

Step 1: Describe Signal Behavior, Not Just Performance

The first step is to stop treating signals as black boxes and instead describe how they behave relative to the market.

Rather than optimizing parameters, you extract behavioral features from each signal’s in-sample return stream. Examples include:

• Market beta
  Does the signal tend to make money when the underlying market rises or falls?
• Volatility beta
  Does the signal benefit from volatility expansion or contraction?
• Average return & win rate
  Does the signal earn profits gradually, or in short bursts?
• Skew
  Does it rely on rare large wins or steady outcomes?
• Trend bias
  Does the signal perform better when the market is up versus down?

These features are not forecasts. They are descriptive statistics that summarize how a signal tends to behave conditional on market state.

This distinction is critical.

You are not predicting regimes — you are characterizing alignment.

Step 2: Convert Continuous Behavior into Discrete Buckets

Raw feature values are noisy and difficult to reason about directly. A signal with a market beta of 0.07 is not meaningfully different from one at 0.05.

Instead of relying on absolute values, signals are ranked and discretized into bins.

For example:

• Market beta → negative / neutral / positive
• Volatility beta → negative / neutral / positive
• Trend bias → low / mid / high
• Skew → negative / neutral / positive

This binning step does something subtle but important:

It removes false precision.

Rather than pretending we know exact sensitivities, we say:

“This signal behaves like a volatility-positive strategy.”

“This one tends to benefit when markets are down.”

At this point, every signal has a behavioral fingerprint, expressed in coarse, interpretable terms.

Step 3: Define Market Behavior Groups

Once signals are discretized, combinations of bins naturally define behavioral groups.

For example:

• Volatility-positive + market-negative
• Volatility-positive + market-positive
• Volatility-negative + market-neutral

Each combination represents a style of signal rather than a specific indicator.

These groups are not arbitrary. They correspond to real market dynamics:

• Risk-off environments
• Risk-on momentum phases
• Low-volatility grind regimes
• Mean-reverting transitions

By mapping signals into these groups, you are effectively answering:

“What kind of market environment is this signal structurally aligned with?”

Importantly, no performance filtering has happened yet.
This is classification, not selection.

Step 4: Slice the Signal Universe by Behavior

With behavior groups defined, the signal universe is partitioned accordingly.

Instead of one massive pool of binary signals, you now have multiple sub-universes:

• Signals that like rising volatility
• Signals that dislike falling markets
• Signals that exploit skew
• Signals that fade trends

Each group contains signals that share structural similarity, not correlation of returns.

This distinction matters.

Two signals can be uncorrelated yet fail in the same regime. Behavioral grouping captures why they work, not just how they co-move.

Step 5: Ensemble Within Groups, Not Across Everything

Once signals are grouped, ensembling becomes far more effective.

Instead of ensembling everything together — which blends incompatible behaviors — you ensemble within behaviorally coherent groups.

This produces ensembles that are:

• Internally consistent
• Regime-aligned
• Less diluted by opposing dynamics

For example:

• A volatility-positive ensemble during risk-off phases
• A market-positive ensemble during trend expansions
• A neutral ensemble during transitions

Each ensemble represents a conditional strategy, even if the final system is unconditional.

Why This Works Better Than Traditional Ensembling

Traditional ensembling assumes diversification comes from low correlation alone. In practice, correlation is unstable across regimes.

Behavioral ensembling works because it diversifies failure modes, not just returns.

A signal fails when the environment changes against it.
A behavior-aware ensemble ensures that some components are always structurally aligned with what the market is doing.

This is not regime prediction.

It is regime coverage.

A Subtle but Powerful Benefit: Interpretability

One of the biggest advantages of this approach is that it produces systems you can reason about.

Instead of saying:

“This ensemble has a Sharpe of 1.2.”

You can say:

“This system blends signals that profit from volatility expansion, market weakness, and asymmetric payoffs.”

That narrative matters — for research iteration, risk management, and capital allocation.

Why This Is Not Curve-Fitting

It’s important to emphasize what this approach is not doing:

• No parameter optimization
• No regime timing rules
• No threshold tuning
• No predictive labels

The features are descriptive.
The bins are relative.
The grouping is structural.

This makes the method far more robust than attempting to predict regimes directly — a notoriously difficult problem.

From Signals to a Market-Aware System

Slicing signals into behavioral buckets reframes system design.

You are no longer searching for universal signals.
You are assembling a portfolio of behaviors.

Each signal is allowed to be imperfect — even fragile — as long as it is honest about when it works.

The ensemble becomes strong not because its components are flawless, but because their strengths activate in different environments.

Final Thought

Markets are not stationary.
Signals are not universal.
Averaging behavior hides information.

By slicing signals into behavioral buckets and ensembling them intentionally, you move from signal hunting to market-aware system design.

Not every signal needs to work all the time.

It just needs to know when it belongs.