When Tiny Errors Become Thousands: The Prediction Chain Trap

I Thought My Math Was Right

I'm staring at a backtest result that doesn't make sense. The single-hop arbitrage predictions look fine — within a fraction of a percent of what actually executes on-chain. The two-hop predictions are still acceptable. By four hops, the predicted profits and the realized profits are in different universes. The math at each step is correct. The model at each step is the same model I'm using everywhere else. Yet somewhere between hop one and hop four, my predicted edge has evaporated into noise.

I assumed accuracy would degrade gradually as I chained more steps. It isn't degrading gradually. It's degrading geometrically. And the deeper I look into why, the more I realize this isn't a bug in my code — it's a structural property of any system that predicts in chains. The bot didn't lie to me. The chain did.

The Telephone Game, But With Money

The telephone game every American kid plays in elementary school works like this: a teacher whispers a sentence to one kid, that kid whispers it to the next, and by the time the message reaches the back of the room, "the quick brown fox jumps over the lazy dog" has become something like "the truck round socks dump lever this acid log." Each kid is only off by a little. Each kid is doing their best. The compounding distortion is what kills the message.

That's exactly what's happening inside my predictions. When I chain prediction steps — predict the price at hop 1, use that prediction as the input for predicting hop 2, then use that for hop 3 — every step inherits the error from every step before it. There's no mechanism in the chain that resets the error. The output of step N is the input to step N+1, errors and all.

In machine learning research, this has a name: autoregressive rollout. The University of Pennsylvania's School of Engineering published a paper in April 2025 (Somalwar et al., "Learning with Imperfect Models") that lays out the mechanism precisely. Their core finding is the kind of sentence that ruins your afternoon: when a one-step prediction model is rolled out across multiple steps, "small errors may compound over time, leading to poor long-horizon prediction." The error doesn't fade. It amplifies.

Why Errors Don't Add — They Multiply

The instinct most people have — the instinct I had — is that if each step is off by 1%, then after ten steps you'd be off by maybe 10%. That mental model is wrong because it treats error like a tab at a sports bar: each round adds to the total, but the total stays a sum. In an arbitrage chain, error isn't a sum. It's a product.

In a multi-hop arbitrage path, the conversion at each hop is a ratio. Hop 1 turns X into X·r₁. Hop 2 turns X·r₁ into X·r₁·r₂. By hop N, you have X multiplied by every ratio along the way. If each ratio carries a small error ε, the cumulative result isn't X(1 + Nε). It's X(1 + ε)^N.

That distinction looks pedantic. It isn't. Here's what (1 + ε)^N actually does:

• 1% error per step, 10 steps: roughly 10.5% total error
• 2% error per step, 10 steps: roughly 21.9% total error
• 5% error per step, 10 steps: roughly 62.9% total error
• 10% error per step, 10 steps: roughly 159% total error

The kicker isn't the 10-step result — it's how the curve bends. Push that 5%-per-step error out to 20 steps and you don't get 100% total error. You get over 165%. The function is compound interest, the same formula that turns a modest retirement contribution into a comfortable nest egg over thirty years. Except what's compounding here is wrongness instead of money, and the time horizon is hops, not decades.

The Duke University and University of Pennsylvania paper "Why Do Transformers Fail to Forecast Time Series In-Context?" (October 2025) puts a clinical name on the failure mode: predictions "collapse to the mean exponentially." Past a certain horizon, the model has accumulated so much error that it gives up on signal entirely and converges to the average. In time-series forecasting, this is called a flat-line forecast — the model literally stops predicting anything useful and just draws a horizontal line at the historical mean. The same paper formalizes the speed: the half-life of useful prediction shrinks with each step added to the chain, and past a horizon set by the system's autocorrelation, the signal is gone.

The Thousand-Fold Drift Is Real

The drift is just compound interest running on error instead of money. At a 1.6× per-step growth rate, fifteen steps already turns a barely measurable initial miss into a roughly thousand-fold blowup — 1.6^15 is about 1,150. The model is wrong by a larger multiple at every hop, and the multiples stack until the prediction has no relationship to reality at all.

The Bachmann and Nagarajan paper "The Pitfalls of Next-Token Prediction" (March 2024) describes the same phenomenon from a different angle. They call it exposure bias. During training, the model sees the true history at every step. During inference, the model sees its own previous predictions. The training distribution and the inference distribution are different worlds. The model was never asked to recover from its own mistakes, so it doesn't.

In arbitrage terms: I trained on observed prices. I'm running on prices I just predicted. The model has no idea how to handle the kind of input it's now generating for itself. It's like asking a driver who only ever practiced on dry pavement to handle a rainy track at race pace — every micro-correction is calibrated for conditions that don't exist anymore, and each wrong correction compounds with the next.

The authors connect this to a 2010 result from Ross & Barto on imitation learning showing that, in the worst case, "the cost of errors grows quadratically with the number of steps in the horizon." Quadratic is already bad. In multiplicative settings like exchange-rate chains, the actual growth is geometric — which is worse still.

The Power-Law Wall in Cross-Chain Arbitrage

If you wanted empirical evidence that prediction chaining destroys arbitrage profitability, you'd find it in the cross-chain MEV data. A November 2025 arXiv paper, "Bunny Hops and Blockchain Stops", analyzed cross-chain arbitrage transactions over a roughly twelve-month window from September 2023 through August 2024.

Here's what they found at each hop count:

• Two-hop arbitrages: common
• Three-hop arbitrages: eight transactions over the full year
• Four-hop arbitrages: two transactions
• Five-hop arbitrages: zero
• Six-hop arbitrages: zero

This is a power-law collapse. The market itself is telling you something: as you add hops, the universe of profitable opportunities doesn't shrink linearly — it falls off a cliff. The authors note that execution time scales roughly linearly with hop count, but "accumulated transaction costs," "execution risk," and "exposure to market volatility" all amplify superlinearly. Combine those superlinear cost pressures with multiplicative error in prediction, and the result is a wall that even very sophisticated arbitrageurs cannot cross.

The deeper theoretical work from Cross and Kozyakin ("Double Exponential Instability of Triangular Arbitrage Systems", originally arXiv 2012, published in Discrete and Continuous Dynamical Systems in 2013) bounds the math: in foreign exchange arbitrage with four currencies, prediction error grows exponentially. With five or more currencies, you can get a "double exponential law" — growth of the form exp(exp(N)). Each additional currency in the network inherits and amplifies the instability of the smaller subnetwork. The authors frame this as "inheritance of instability" — a structural property of the system, not something you can fix by improving individual step predictions.

That phrasing matters. It says: you can't out-engineer this with a better one-step model. The problem isn't the model. The problem is the structure that uses the model.

The Triangle That Always Loses

Triangular arbitrage on a DEX looks deceptively simple. Trade A for B, B for C, C for A, end with more A than you started with. The compound rate r_AB · r_BC · r_CA needs to exceed 1 plus the sum of fees. If you can find that, you profit.

The Coinmonks article on "Triangular Arbitrage with Crypto DEXs" (2023) has a concrete example I keep coming back to. The path is ALGO → USDC → USDt → ALGO. The author starts with 20 ALGO. After three swaps, they end with about 19.21 ALGO — a roughly 4% loss on a path the analytical model labeled "Close to Profit!" That outcome isn't because the math is wrong. It's because the prediction inputs at each hop — quoted output, fee assumption, slippage estimate — each carried a small error that multiplied through the chain.

A 0.5% prediction error at each leg of a three-hop triangle compounds to (1.005)^3 ≈ 1.015, or roughly 1.5% cumulative drift. If the spread you're hunting is 0.3%, the prediction noise has wiped out the edge five times over before any execution risk shows up. And that's at three hops with only a 0.5% per-step error. The actual on-chain conditions — slippage from concurrent fills, price drift between block proposals, fee variance — push the per-step uncertainty above 0.5% routinely.

This is the deeper version of the triangular arbitrage problem: the math says "profit," the prediction says "profit," and the chain says "loss." The math is fine. The prediction was bad. The chain made the bad prediction catastrophic. The triangle isn't unlucky. It's structurally rigged against you the moment any per-step uncertainty exists.

The Spectral Radius Trap

Here's the part that bothered me most when I worked through the UPenn paper. Their Example IV.1 constructs a two-dimensional dynamical system where the true system is stable — its spectral radius is 0.9. By every conventional measure of system behavior, this thing is well-behaved. Disturbances decay. Errors should die down, not blow up.

But the relevant quantity for prediction error isn't the true system's spectral radius. It's the spectral radius of a different matrix that describes how observation error feeds back into the prediction state. In their example, that matrix has a spectral radius of 0.99 — just barely under 1, but enough to cause near-exponential error accumulation across long prediction horizons. The underlying system looks stable. The prediction process looks unstable. The two are different things, and only the second one matters when you're chaining.

In a closed-loop control experiment the same paper describes, the single-step rollout controller — the one chaining its predictions — becomes unstable. The multi-step direct predictor maintains stability. The distinction isn't accuracy at any one step. It's whether the system can be controlled at all over the horizon you care about.

In arbitrage terms, this maps directly. You can have a one-step model that's quite accurate. You can have a market that's quite stable. Yet the moment you chain that model's outputs into a multi-hop search, your prediction system can be effectively unstable — not because anything is broken, but because the structure of chaining amplifies whatever small biases exist. It's the same reason a pool break with a tiny misalignment at every cushion eventually leaves the cue ball nowhere near where geometry says it should be: each cushion is fine, the angle math is fine, but the accumulation of "fine" is fatal.

Breaking the Chain

So what do you actually do about it? The answer isn't "build a better predictor." Better one-step prediction is helpful, but it doesn't escape the compounding wall. If your one-step error is 0.5% and you chain ten of them, you're at (1.005)^10 ≈ 5.1% total drift no matter how clever the model is. Better prediction lets you go a few hops further before the wall hits. It doesn't move the wall.

The structural fix is to stop chaining. Predict only the step you can't observe. For every step you can observe directly, use the observation, not a prediction.

In a typical multi-hop arbitrage path, there's an opportunity hiding in plain sight: most of the intermediate state is already observable. Pool reserves are on-chain. Recent prices are on-chain. The current block's state is on-chain. The thing you actually need to predict — the question you can't answer just by reading state — is what your own transaction will execute at given current conditions. That's one step of prediction. Not N.

Every step you replace with an observation collapses an entire branch of the compound-error tree. Instead of (1 + ε)^N, you get (1 + ε)^1. The math becomes manageable again. The backtest stops disagreeing wildly with reality at long horizons. The phantom profits at hops 4 and 5 disappear because they were never real — they were artifacts of chained noise, not signal.

This is the same insight the UPenn paper recommends in academic terms: under misspecification — which is essentially every real-world condition — fall back to direct prediction wherever possible. The Coinmonks article reaches a related conclusion from a different angle when it converts the multiplicative arbitrage detection problem into an additive one via log-space transformation (ln(r₁₂ · r₂₃ · r₃₁) = ln(r₁₂) + ln(r₂₃) + ln(r₃₁)). Different toolkit, same principle: get out of multiplicative compounding wherever you can, whether by replacing prediction with observation or by mathematically restructuring the search itself.

What This Changes

The first thing it changes is what counts as a "good" prediction model. For a long time I was optimizing for one-step accuracy. The right metric for an arbitrage search is end-to-end accuracy — realized profit divided by predicted profit across the full path. A model with 0.3% one-step error chained ten deep is worse than a model with 0.8% one-step error used in a single-step lookup against observed state. The chain isn't a neutral wrapper around the model. It's an amplifier whose gain depends on chain length.

The second thing it changes is path selection. Three-hop paths aren't just "two more risky" than one-hop paths — they're geometrically more risky in a way that scales with however accurately your prediction model performs. The empirical evidence from cross-chain arbitrage isn't just an interesting data point. It's a hard cap on what's findable. If a year of observation across the entire market finds zero five-hop opportunities, the right inference is not "I should find them." It's "the structure of the problem prevents them from existing in any number that matters."

The third thing it changes is design priority. The instinct for any system that interacts with chains of state is to model the chain. The better design is to flatten the chain — to push as much of the work into observation and as little into prediction as possible. Every step you can read directly is a step you don't have to forecast. Every step you don't have to forecast is a step that doesn't contribute to compound error.

The hard part is admitting that some of the most interesting-looking opportunities — long paths through obscure tokens, multi-DEX rebalancing chains — aren't actually opportunities. They're chains long enough that any model would be hallucinating profit through accumulated noise. The mathematics doesn't care that the path looks promising on paper. The mathematics says the noise grows faster than the signal, and after a certain depth there is no signal left to recover.

That's an uncomfortable conclusion when half your search space evaporates the moment you accept it. It's also the only honest one. I'd rather hunt the two-hop paths I can verify than the five-hop paths I can only dream about.

Key Takeaways

• Prediction errors in chained systems multiply, they don't add. A 1% per-step error compounds to (1.01)^N total error, which is super-linear in N. By 20 steps, even 1% errors per step have driven total error past 22%, and the curve only bends harder from there.
• The cross-chain MEV data confirms the structural limit empirically. In a roughly twelve-month study, researchers found eight three-hop arbitrages, two four-hop, and zero five-hop or longer. The market itself demonstrates where compounding error eliminates profit margins.
• A "stable" one-step model can still produce an unstable prediction chain. The University of Pennsylvania paper's Example IV.1 shows a system whose true spectral radius is 0.9 — stable by conventional metrics — but whose prediction process has effective spectral radius 0.99, generating near-exponential error growth across long horizons.
• The solution is structural, not algorithmic. A better predictor doesn't escape compounding; only fewer prediction steps do. Replace every predictable step you can with a direct observation of on-chain state. Predict only what you genuinely cannot read directly.
• End-to-end accuracy is the right metric, not one-step accuracy. A model with worse per-step error used in a flat structure outperforms a model with better per-step error used in a deep chain. Optimize the structure first, the per-step model second.