At 18:30 my phone buzzed with what looked, for about four seconds, like the best news of the month.

7549 windows ≥5.0bps · median 30ms · p95 1060ms capturable in-region (>50ms): 24%

Translated out of robot: across a day, my measurement box in Singapore had watched the same coin trade at two different prices on two different exchanges seven and a half thousand times. Nearly a quarter of those gaps stayed open long enough that a normal Python bot — no Rust, no exotic hardware, just a cheap server sitting in the right city — could have reached out and grabbed them.

A quarter. Of seven thousand. That's not a trickle. That's a faucet.

I let myself enjoy it for those four seconds. Then I pulled the second number, the one the report wasn't printing yet. And the faucet turned out to be a photograph of a faucet.

The number under the number

Here is the same day, with the part that matters added:

16,370 paper trades simulated · net-profitable after fees: 191 · 1.2%

The box doesn't just count the gaps. It also pretends to trade them — fills both legs thirty milliseconds after a gap opens, the way a real in-region bot would, then subtracts the fees both exchanges charge to get in and out.

Sixteen thousand simulated trades. One hundred ninety-one of them made money. One-point-two percent.

The "24% capturable" was real. The gaps were real, they were reachable, the fast seat I'd rented worked exactly as advertised. It just didn't matter, because the gaps were five to ten thousandths of a percent wide, and it costs about eleven thousandths of a percent to cross both exchanges.

You can see them all. You can reach them all. And almost every one is a dime lying on the ground behind an eleven-cent toll booth. The walk was never the problem. The toll was always bigger than the dime.

The 191 winners are a mirage too

"Fine," I said to myself, "but 191 trades did clear the toll. Maybe the edge is just narrow." So I looked at who they were. They fall into three buckets, and all three are traps:

The ones that ran away. INJ threw 54 winners averaging a healthy-looking gap — but in the two seconds after the imaginary fill, the price had already moved twelve thousandths of a percent further in the wrong direction. The gap looked profitable because the market was already sprinting away from it. Fill one leg and you'd watch the other gap out before you got there. That's not an edge you capture; that's a pickpocket you fund. There's even a name for it — adverse selection — the polite term for "the only trades you can get are the ones you'll regret."

The ones with no edge. Solana had six winners on a genuinely deep market — thirty-five thousand dollars of size sitting right there, real liquidity. The profit, after the toll, was a sixth of a thousandth of a percent. One tick of slippage and it's gone. The market was deep because it was efficient.

The ones with no room. ARB showed a "fat" edge — on sixty-one dollars of depth. You couldn't put a real position through it without eating the entire order book and turning the profit into a loss on the way.

The pattern is iron, and it's almost beautiful once you stop wanting it to be otherwise: where there was depth, there was no edge; where there was an edge, there was no depth, or the price had already gone. That's not a market with a crack in it. That's the photograph of a perfectly sealed one.

What the autopsy was actually for

A few weeks back I rented a $6 server to prove that my old "a solo dev can't win latency races" verdict was confounded — my dead server had been in the United States, ~180 milliseconds behind an exchange whose engine lives in Singapore. I'd tested geography and concluded things about talent. The $6 box got me to 8 milliseconds and proved the seat was reachable.

That post ended on a tease: the gaps are reachable — but are they worth reaching? This is the answer, and it's the whole reason the first experiment mattered. By removing geography as a variable — by actually buying the fast seat — I could finally isolate the one that was left.

It wasn't latency. It was the fee floor. It always had been. The eleven thousandths of a percent that both exchanges take is larger than the edge that exists at any speed a human can buy. My dead US server never had a chance, but not for the romantic reason ("too slow, outgunned by the pros"). For the boring one: it was trying to harvest a crop smaller than the cost of the harvest. So would a perfect bot. So would a bot written in Rust running on the exchange's own roof.

The rewrite that measurement talked me out of

This is the part I want the other builders to take. The seductive next move, the one every instinct screamed, was: we're at 30 milliseconds, rewrite it in Rust, get to 5, capture more.

The measurement said: you would be paying to arrive faster at a loss.

Going from 30ms to 5ms moves you along a curve — and every single point on that curve is underwater. Faster doesn't lift the curve; the toll lifts the curve, and I don't control the toll. The most expensive code I didn't write this year is the Rust rewrite that 16,370 paper trades told me was a beautiful way to lose money 0.3% faster.

I have an AI co-engineer in all of this, and I'll be honest about the division of labor here, because it cuts against the usual story: the machine was the one holding the line on "measure first, rewrite never." Left to my own enthusiasm I might have spent a fortnight in Rust. The discipline was a 200-line script that just counted, ran for free while I slept, and refused to let me confuse a faucet with a photo of one.

When success looks like failure

Here's the reframe that took me a day to accept.

The autopsy didn't fail. It succeeded. It was built to answer exactly one question — do the profitable gaps cluster at speeds a normal person can reach? — and after sixteen thousand trials it answered, with a sample size no one can argue with: no. 1.2%, and even those are mirages.

A kill backed by 16,370 data points is not a defeat. It is the single most valuable thing the box could have produced, because the alternative was finding this out slowly, with real money, one disappointing month at a time. The 95%-lose-money trading internet would have sold me a course on this exact setup. I got the opposite of a course: I got the real answer, and it cost six dollars and two weeks of a server humming in a data center I'll never see.

The market was efficient. We paid to find out for certain instead of paying to find out slowly. If I had to compress this entire company into one sentence, that would be it.

The box keeps running until the end of the month — partly for an even bigger sample, partly because while it's there it's also recording every forced liquidation on the exchange, which is a different question for a different night. Then I'll pull its database home, switch it off, and write the gap a proper headstone with these numbers carved into it. Not "we think this is hard." "16,370 trades. 1.2% alive. Latency was never the constraint."

Burials around here come with evidence. This one came with sixteen thousand pieces of it.

What it cost / what it taught: $6 and two weeks of a server's life / the win and the kill are the same skill — measuring something honestly enough that you'll believe the answer even when it's "no." Most edges die at the fee floor, not the finish line; the cheapest experiment you'll ever run is the one that proves you shouldn't run the expensive one.