THE LATENCY LADDER: FOUR GATES THAT REJECT CURVE FITS
Our latency ladder has 7 rungs and 4 gates, and one of them is a veto. The random-jitter gate rejects a strategy that looks strong only at one assumed delay: the 150 ms deployment point.
A backtest that fills every order instantly is a fiction. We built the latency ladder to answer a harder question than "is this strategy profitable": how much of the profit is a latency tax, and where does that tax turn lethal? The answer runs across seven latency conditions and four gates, each written at a different rung for a different reason.
The stakes are clear. A strategy that is rank-one at zero delay and rank-last at random jitter is not a strategy. It's a curve fit to a single latency assumption, and the ladder exists to catch exactly that disguise.
#The latency ladder has seven fixed rungs
The latency ladder has 7 rungs: no delay, 50 ms, 100 ms, 150 ms, 300 ms, 500 ms, and random jitter. The list is closed. "That's it" is the documented position, and the discipline matters: an open-ended ladder lets an operator shop for the number that flatters the result.
| Rung | What it represents | What it asks |
|---|---|---|
| No delay | The reference — the ideal fill | Is there any profit at all? |
| 50 ms | A good colocated path | Does the edge survive a small, real delay? |
| 100 ms | A normal retail bridge | Is the edge degrading? |
| 150 ms | The deployment point | Does the strategy earn its keep where it will actually live? |
| 300 ms | The tail of bad nights | Does it hold ratio and refuse to blow up? |
| 500 ms | The pathological case | How deep is the cliff? |
| Random jitter | Every band at once | Is the edge independent of any single latency? |
Six rungs are fixed points; the seventh is the whole distribution. A fixed rung asks what happens at one latency. Jitter asks the harder question, because it does not let a strategy hide on the rung where it happens to look good.
#Closed, and that is the feature
The closed list is a feature, not a limitation. An open ladder invites a very specific dishonesty: after the run, an operator adds the rung where the strategy still looks strong, drops the rung where it collapsed, and files the result as realistic. A closed list removes that option entirely, and it buys three things no open ladder can. Two strategies get measured on identical conditions, so their rankings are comparable. Two waves of the same strategy get measured identically, so drift between them is legible. And the ranking weights have a fixed domain, which means an expectation value computed this year can be recomputed next year and mean the same thing.
The discipline costs real information. The ladder will never include the exact latency a particular broker happens to have on a bad Tuesday. That cost is worth paying because the information it removes is the kind nobody can audit anyway.
#What 150 ms actually does to a fill
Delay changes each execution type differently. It is not a tax applied equally to everything, and the pattern of what degrades is diagnostic information, not just a score.
- A signal that assumed an instant fill at the quoted price now fills at a moved price: cost, arriving silently.
- A limit-style intent that was only good at one price can go unfilled entirely: missed entries, which do not always look like losses in the report.
- A protective exit that fires late keeps a position open longer than the logic asked for: risk, compounding quietly into drawdown.
The fixed-delay leg makes execution failures visible. A strategy whose profit collapses uniformly across every execution type has one problem, and it is usually execution. A strategy whose profit holds while its entries quietly stop firing has a different problem, and only the fixed-delay leg makes that difference visible with numbers attached.
#Four gates test reference, deployment, tail, and jitter
A candidate survives only when all four gates, G1-G4, hold together. No gate is redundant; each one guards a different failure mode.
| Gate | Rung | Condition | The failure it catches |
|---|---|---|---|
| G3 | No delay (reference) | Positive profit | No edge existed in the best case — nothing else is worth reading |
| G1 | 150 ms (deployment point) | Profit > 0 and profit > drawdown | Barely-positive: the strategy works but has no margin for a worse world |
| G2 | 300 ms (tail) | No blowup and ratio ≥ ~0.6 | The ratio collapse — profit survives but quality dies |
| G4 | Random jitter | No blowup — full stop | Latency-shaped luck: the edge only exists at one latency |
The gates ask increasingly honest questions. G3 is a sanity check. G1 is a business test. G2 is a survival test. G4 is a character test, and it is written as a veto, not a score.
The 50 ms and 100 ms rungs are deliberately ungraded. They describe how fast the edge degrades, not whether it survives. A degradation gradient from 50 to 300 ms tells you the strategy's half-life, which is decision-relevant intelligence. But the gate that decides is written at the deployment point and the tail, because those are the only two places where a verdict can be pre-committed without shopping for a flattering number. Writing the gates at the places that matter was a deliberate refusal to grade the gradient.
#The random-jitter gate is an unconditional veto
The jitter gate does the most work and is deliberately the crudest. Its condition is a single bit: no blowup. Not a ratio, not a threshold, not a weighted average. A blowup at any sampled latency is an unconditional reject, and no other gate can argue it back.
A jitter-failing champion is rejected no matter how good its 150 ms row reads. The reason is structural. Passing at every fixed rung (0, 50, 100, 150, 300, 500) is not evidence of latency robustness. A strategy can be perfectly tuned to the assumption that every fill takes exactly 150 ms, and such a strategy will pass every fixed point that matters while being fragile to the entire distribution around those points. Jitter samples all bands at once, so it is the only rung that cannot be gamed by a single assumption.
A strategy that dies under jitter was really a strategy about 150 ms. Everything above the deployment point was decoration. The veto's job is not to punish that strategy; it is to remove it from the ranking, so the surviving candidates are ranked on edges rather than assumptions. A ladder without a veto does not rank strategies; it ranks fits.
#Ranking uses a fixed expectation value for each range
Gates decide survival; the latency ladder also ranks survivors. The ranking metric is an expectation value: a weighted sum over latency bands, where each band's weight is its probability and the term is the strategy's metric in that band. Two rules keep the number honest.
The weighting is fixed before the run. A ranking that lets its weights move after the results are seen is a shopping exercise with arithmetic attached: any strategy can be made rank-one by concentrating weight on the band where it happens to be strong. The honest version asks what latency a deployment actually experiences, writes the weights down, and lets the sum fall where it falls. A strategy that only wins at one weight vector is telling you its edge is conditional, and the expectation value is simply the arithmetic that refuses to keep it secret.
- Per range, never across. The expectation value is computed within each range and reported per range. Averaging across ranges lets one smooth week cancel a blown week, and a strategy that blows up once is not a strategy.
- Bands come from the closed seven. The weights describe the real latency distribution of the deployment, not a grid chosen after the results were seen. The ladder is fixed before the run, and the weights are fixed before the run.
| What the gates do | What the ranking does |
|---|---|
| Binary survival: hold all four, or the candidate is refused | Orders the survivors, richest information first |
| Written before the run, never re-derived after | Computed per range, so every window stands alone |
| Protects against the worst case (G2, G4) | Rewards breadth across the latency distribution (G1, G3) |
#Documented latency gates do not run in the application yet
The four gates are documented, but none is enforced in code. Their thresholds and the seven-rung ladder live in the lab's decision files. In the application that runs the waves, they have no representation at all: no gate object, no threshold, no pass/fail evaluation, anywhere in the codebase. The verdict actually enforced today is not any of these gates; it is the terminal's own journal, re-parsed at the registration door, where a run whose journal does not carry the passed token is treated as unproven.
Where a gate is vacuous, the verdict is "not measured here", never "passed".
A gate that is written but unwired is only a manual review step. Pretending otherwise is how a lab starts trusting numbers it never measured. The remedies are as boring as the defect: pre-commit the gate table before running a wave, execute it in code so it cannot be argued with after the fact, and record which verdicts came from a machine and which came from a human.
Latency and robustness are separate decision layers, but code does not enforce that separation. The decision rules treat the two documents as sequential gates, not siblings. The ladder's legs encode exactly that: the delay leg carries no robustness layer, and the robustness leg runs clean. Nothing in the scheduling layer enforces the separation, so a run's execution semantics are settled by what its own run record carries, not by what the ladder documents say. In practice, the leg labels on an old wave cannot be trusted on their own; the record that produced the rows has to be checked against the protocol the run was bound to.
#A closed latency ladder keeps rankings comparable
Seven rungs, four gates, one veto, and a ranking computed per range. The ladder's power comes from what it refuses to do: it refuses extra rungs, refuses cross-range averaging, and refuses to let a beautiful 150 ms row outvote a blown jitter band. Write the gate table before the run; run it after. Everything else is rationalization with a spreadsheet.
- The rung list is closed on purpose: an open ladder lets the operator shop for the number that flatters the result.
- G4 (random jitter) is an unconditional veto. A strategy that dies under jitter was a strategy about 150 ms, and decoration does not rank.
- Gates are documented, not wired: an unwritten verdict counts as "not measured here", never "passed".
The next step is to wire the gate table before trusting a rank. The gate tables, per-range rankings, and raw runs are in the DAAVILEFX Quantum research dashboard. We pair these conditions with a bit-identical control cell and a deleted wave case study before trusting results. The broader published performance results show what survived those checks.
#Questions we get asked
#What is the latency ladder?
It is a closed set of 7 rungs: no delay, 50 ms, 100 ms, 150 ms, 300 ms, 500 ms, and random jitter. Each rung tests a different execution condition.
#Which gate rejects a strategy?
G4, the random-jitter gate, is a veto. Any sampled latency blowup rejects the candidate, even if its 150 ms row is strong.
#Why are the 50 ms and 100 ms rungs not gates?
They show how quickly the edge degrades. The pass/fail gates sit at the reference, 150 ms deployment point, 300 ms tail, and random jitter.
#Are the four gates enforced automatically?
Not yet. They are documented, but the application has no gate object or threshold evaluation, so an unwired gate must count as not measured, not passed.