DEV Community: Dry Run

A decorrelated bot that loses money is just a diversified way to lose money

Dry Run — Tue, 22 Sep 2026 11:15:12 +0000

I added trend-following bots to my fleet to decorrelate it. The correlation matrix said it worked. The P&L said it didn't. Here's the number that settles the argument.

I run a small fleet of trading bots in paper mode. Most of them are variations on the same idea — mean-reversion on crypto: buy the dip, scale in, exit in green. Running five bots that all do the same thing isn't a fleet, it's one bet with extra logging. So I deliberately added bots designed to make money when the dip-buyers struggle: trend-followers (a Donchian breakout, a Supertrend). A trend-follower next to a dip-buyer is supposed to be out of phase — one eats ranging chop, the other eats sustained moves. On paper, textbook diversification.

Then I measured it. Two months of daily P&L snapshots, five bots. The correlation matrix lied to me in both directions, and untangling how is the most useful thing I've done to the fleet all quarter.

What "diversified" actually looked like

I take a snapshot of each bot's P&L every day (realized plus the mark-to-market on open positions) and correlate the daily changes. Two numbers stopped me:

The two bots I was most confident were diversified — my aggressive dip-buyer, and a second instance of the same strategy running on a different exchange — correlated at 0.93. They're the same strategy on two venues, and the market doesn't care which venue you're on. I wasn't running two bots. I was paying twice for one bet and calling the duplicate "diversification." (The more conservative sibling of the same family came in at 0.51 — better, still the same reflex reacting to the same dips.)
The bots I added specifically to decorrelate — the trend-followers — actually delivered on the correlation axis. The breakout bot correlated with the dip-buyers at around 0.05. That's about as uncorrelated as two things trading the same asset class get. On this axis, the plan worked exactly as designed: when the mean-reverters zigged, it zagged.

So the "diversifiers" I trusted were secretly the same bet, and the "diversifiers" I added on purpose were genuinely uncorrelated. Great news, right?

The correlation matrix is a liar of omission

Here's the P&L over the same window:

Breakout bot: −445 units. Its backtest over a roughly −41% market was −42%, with a negative Sharpe. A confirmed, structural money-loser.
Supertrend bot: +501 units — the best raw P&L in the entire fleet — on a strategy whose backtest over the same cycle was −52%, Sharpe −5.8. The paper gain was a regime mirage: two lucky months sitting on top of a strategy that bleeds across a full cycle.

Now put the two facts together. My beautifully decorrelated breakout bot (r ≈ 0.05) has negative expectancy. Adding it to the fleet doesn't reduce portfolio risk — it adds a stream of losses that merely happens to arrive on different days than everyone else's. That's the trap, and it deserves to be stated as a rule:

Decorrelation only helps a portfolio when it's multiplied by an expectancy that isn't negative. A decorrelated bot with negative edge is not a hedge. It's a diversified way to lose money.

Low correlation is necessary for diversification, not sufficient. The textbook version quietly assumes every leg has a non-negative return and only the timing differs. Drop that assumption — as any real, unvetted strategy forces you to — and the correlation coefficient becomes exactly the kind of flattering metric that hides the failure mode. It told me the breakout bot was a great teammate. The expectancy told me it was dead weight in a different jersey.

What I did about it

I paused both trend-followers. Not because they were correlated — they weren't — but because "uncorrelated and losing" is worse than useless: it loses money and adds operational surface area to babysit. Low correlation earned them a second look; the backtest and the net-of-open-positions P&L is the test they actually had to survive, and they failed it.

That left the real question. If a second crypto strategy can't decorrelate my crypto fleet — they all ultimately trade "is crypto up or down today" — where does real decorrelation come from? Not from another strategy on the same asset class. From a different asset class entirely. The genuinely independent engine in my fleet is a dual-momentum ETF bot running on a stock broker: different market, different instruments, and a different clock — it rebalances once a month instead of reacting intraday. Its P&L physically can't correlate 0.93 with a crypto dip-buyer, because it isn't looking at the same universe on the same timescale. That's structural decorrelation, not a strategy I bolted on and hoped.

The general lesson (as usual, not really about trading)

This is a portfolio problem, but it's the same shape as every system where you add redundant components and tell yourself you've bought resilience:

Two services behind one load balancer, both calling the same downstream database, are one point of failure with two hostnames. Their availability is 0.93-correlated whether the architecture diagram admits it or not.
Three "independent" safety checks all fine-tuned from the same base model tend to be wrong on the same inputs. You think you bought an ensemble; you're running one opinion in triplicate.
A backup in the same region, same account, same blast radius as the thing it protects is decorrelated on paper and perfectly correlated the one day it matters.

The engineering move is identical every time: don't count boxes, measure the correlation of their failures — and then check that each box has a positive reason to exist on its own. Redundancy that shares a hidden root is fake redundancy. And a component that's genuinely independent but quietly broken doesn't harden the system; it just spreads the breakage thin enough to be hard to see.

I added losing bots on purpose to decorrelate a fleet, and the measurement taught me two things I didn't want to hear: the bots I trusted were the same bet, and the bots that were truly independent weren't worth keeping. Real diversification wasn't a cleverer strategy — it was a different asset class with a different clock. Everything else was correlation theater.

One honest caveat: two months of paper data across a single market regime is a small, ugly sample, and every number above will move. I'm not reporting constants — I'm reporting a method. Measure the correlation of failures, then demand that each leg justify itself standalone. That part survives the sample.

I document a fleet of autonomous trading agents as an engineering problem — evaluation, risk, reliability — not as trading advice. No signals, no tips; just what breaks and how I try to catch it first. Follow along if that's your thing.

A 100% win rate is a red flag, not a résumé

Dry Run — Tue, 18 Aug 2026 14:52:18 +0000

What running a fleet of autonomous trading bots taught me about picking the right metric.

I run a small fleet of automated trading bots in paper mode. One of them — a mean-reversion strategy on crypto — closed its first 34 trades without a single loss. 34 out of 34. A 100% win rate.

If I put that number on a landing page, it would sell. It's also close to meaningless. Here's why, and why it changed how I evaluate any autonomous system I put in production.

The number is real. The conclusion isn't.

The strategy belongs to the "buy the dip, scale in, exit in profit" family. Two mechanics produce that spotless record:

It scales into losers. When a position moves against it, it adds to the position at a lower price, dragging down the average entry. A trade that would have been a 4% loss becomes a 0.5% win after two add-ons.
It only ever closes in green. There's no time-based or loss-based exit in the base logic. A position that's underwater simply... stays open. It isn't a loss until it's realized, and it's never realized at a loss.

Put those together and a 100% win rate isn't evidence of skill. It's the definition of the strategy. The metric is measuring the exit rule, not the edge.

Where the risk actually lives

The losses don't disappear — they move to places the win rate doesn't look:

Locked capital / time under water. In a bear backtest, this style held some positions for up to 121 days. Capital busy averaging down a bag is capital that isn't compounding. Win rate says nothing about that opportunity cost.
Tail risk. Scaling into a falling asset works beautifully until the asset doesn't come back. The distribution of outcomes has a fat, ugly left tail that a "100% so far" record hides completely. You don't see it until a trend breaks and the temporary drawdown becomes permanent.
Sequence risk. 34 trades in a calm, ranging market tells you how the strategy behaves in a calm, ranging market. That's it.

None of this is a knock on the strategy — scaling in is a legitimate approach. The point is that win rate is the wrong lens for it. It's a vanity metric here, the same way "99.9% of requests return 200" is a vanity metric if you never look at the 0.1% that time out and take the checkout flow down with them.

The rule I run by now

Because the flattering metric is worthless, I won't let a bot near real money on the strength of it. The go-live criteria I actually use:

A minimum number of trades (I use ≥100), so I'm looking at a distribution, not an anecdote.
Survive at least one real correction in paper mode. The entire risk of this strategy lives in a downtrend it can't average out of. If it hasn't lived through one, I haven't seen the number that matters.
Drawdown, time-under-water, and a Monte Carlo reshuffle of the trade sequence — because the order the trades happened to arrive in is one sample, and I want the P95/P99 of the drawdown, not the single lucky path.

Win rate isn't on the list. Neither is total P&L over a too-short window.

The general lesson (this isn't really about trading)

The bot is just a clean example of a trap that shows up wherever you operate an autonomous system: the system will happily hand you the metric that looks best, and it's usually the one that hides the failure mode.

An agent that "completes 100% of tasks" might be quietly narrowing what counts as a task. A pipeline with "zero errors" might be swallowing them. A model with a great average score might be catastrophic on the 2% of inputs you actually care about.

The engineering job isn't to collect the flattering number. It's to design the evaluation so the failure mode has to show itself before it costs you. For my bot, that means judging it by how it behaves in the drawdown it's built to avoid looking at — not by the streak it produces when nothing goes wrong.

A 100% win rate didn't make me trust the bot. It's the thing that made me go looking for what it was hiding.