Jev harness lab

Waiting for a run.

A verdict needs at least 30 decisions, and then it is read off t against the random control — not off whichever line is highest.

CAD, unblocked — and the composition result replicates

We said CAD was blocked on a missing API. It wasn't. We probed the wrong paths.

This page claimed for two days that a cad demo was impossible because cad.mino.mobi/api, /api/health and /docs/CAD.md all 404. Those 404s are real and all three are paths that were never the API. It has been live for weeks at cad.mino.mobi/mcp — JSON-RPC, GET returns a descriptor — with check (resolve a tree, ~40ms), build (the Truck kernel: volume, area, bbox, centroid, Euler characteristic, watertightness, every named face, ~90ms for this part), plus measure, interference, mechanism, drawing and STEP export, and a bench of worked parts. Correcting it in public because the claim was published in public.

So the sprite chain ran again, with a real kernel supplying both the legality and the ground truth. Bench part plate, three briefs over kernel-measured invariants.

Beat random 3/3, within 5% of the greedy ceiling 2/3, and every part built along every chain came back watertight. 312 distinct kernel builds at 89ms each. The gate fired on 7 of 18 edits and 100% of those improved.

And the self-check failure replicates exactly. p(have) came back 0.113, 0 of 18 above 0.5 — against 0.10–0.12 on the sprite chain. Different domain, different kernel, different question, same number. That makes the composition finding an independent replication rather than a quirk of one generator: in a sequential loop the self-check says “no” to everything and confidence is the informative signal, which is the reverse of every frozen-state result on this page.

Two things the kernel taught us that a cheap check cannot

check does not validate geometry. It passed a tree with the pillar holes 999mm off a 20mm disc, a negative thickness, and R = 0. Only build rejected the last one. So the “search that cannot propose an invalid model” property lives entirely in the enumerator — it is not something a kernel's fast path hands you. Ours encodes the coherence rules explicitly (centre hole inside the rim, bolt circles fitting within the disc) and refused 20 of 696 candidates as not-a-part, which were never shown as options.

And valid is not correct. Setting r_centre to 25 on a disc of R = 20 builds cleanly: watertight, volume 1065, bbox grown to 24mm — the even-odd composition flipped which region was solid. A part can resolve, build, be watertight and still be the wrong part. Nothing on the kernel side catches that, which is the strongest argument for writing the constraints down rather than trusting a green build.

Caveats: one bench part, three briefs, six edits, and greedy is a myopic ceiling — matching it is not evidence of planning. The briefs were written by the same person reading the results.

Composition: the hypothesis nobody had tested

Breadth was proven long ago. A chain had never been run once.

Every measurement on this page has been independent questions against one frozen state — 1024 at once, 549ms, all correct. But a sequence where each decision changes the state the next question is asked against is a different animal, and it is what procgen and CAD both actually need. The harness enumerates the legal edits, computes what each would do, and Jev picks. The enumerator only emits clamped, buildable genomes, so no round of the loop can produce an invalid creature whatever the model answers — the safety property, doing real work at last.

→

brief: a fast, lightly-built runner.
depth_up → body_down → body_down → stride_up → depth_up → stride_up → ear_down → ear_down → ear_down → body_down

It composes. Beat the random control on 8 of 8 chains, landed within 5% of the greedy ceiling on 7 of 8, and never once took the worst move on offer. Regret 0.020 against greedy's 0.000 — it is doing what an optimal myopic rule does, by judgement rather than by search.

But the first version was mediocre, and the fix is this page's oldest lesson. It scored regret 0.717, beat random only 6/8, and one chain diverged to 3× worse than its start. Two things were wrong and both are in the archive above: the question asked which edit “best moves toward” the brief — which is about a path, i.e. a forecast — and the criteria handed over six trait deltas per option for the model to combine, which is the multi-step arithmetic that scored 62.5% until the caller did it. Asking “which leaves the smallest gap” with that gap pre-computed moved regret 0.717 → 0.020 and the gate from 0/80 to 21/80, every one of which improved. Same model, same enumerator, same chains.

And the self-check broke, for the first time

p(have) sat at 0.10–0.12 on all 80 edits and never once cleared 0.5 — while the chain ran at the greedy ceiling with 97.5% of edits improving. On four prior datasets the self-check was the reliable signal; here it says unanswerable about the one question it exists to gate, and is wrong.

Isolating it — same document, same call, two determinate questions:

So it is not the composition context. The same document answers 0.962 for a lookup. It is specifically the edit question — and the best reading, offered as a hypothesis rather than a finding, is that the self-check separates facts about now from facts about a hypothetical, and a counterfactual stays a hypothetical even when you have computed it and printed it in the option. It is a good detector of “is this a description or a projection”, and an action's outcome reads as a projection.

Which inverts the routing rule, and that is the finding. On frozen state the self-check is reliable (62–76 point margins) and confidence leaks. In a chain it is the other way round: confidence was informative — 21/80 above 0.9 and 100% of those improved — while the self-check would have escalated every single edit, which is condition 3 of “when this pattern is worth building” failing in a new way. You cannot reuse the frozen-state routing rule in a sequential loop.

Caveats: 8 chains, 10 edits, one generator family, four briefs, and the briefs were written by the same person reading the results. Greedy is a myopic ceiling, so matching it is not evidence of planning — a chain that needs a temporarily-worse step to reach a better place is exactly what this design cannot yet test.

Carry: the first signal here that is observed, not forecast

And the only one where the gate came back 100% correct.

Everything else on this page tried to predict direction and failed honestly — 51.4% on six-hour windows, 51.7% on stream B, 31.1% on the cross-sectional predictive probes. Carry needs no prediction. The funding rate is printed. The staking yield is printed. The distance to liquidation is arithmetic over printed numbers. Same experiment as before: determinate and predictive probes, same document, same call, 30 evaluation points over 90 days of hourly funding, ground truth computed.

93 of 93 correct above the gate. Routing on the self-check as well keeps those 93 at 100.0% with zero predictive answers wrongly kept — confidence alone would have kept 10. The self-check margin is 65.5 points (0.832 determinate against 0.178 predictive) where answer-confidence managed 15.

The table earns its keep immediately. XMR pays the most headline funding — and has the worst drawdown. UNI carries the best ratio of carry to drawdown by roughly 7×, and ARB sat 4.94 standard deviations above its own 90-day mean with 27% negative hours and a 15-day recovery: the one that looks best and is worst. Short the richest is the wrong trade, and the column that says so is a sort, not a forecast.

Two failures replicated, which matters more than the successes. p_richest_next scored 66.7% — but it answered XMR on 28 of 30 windows, which is restating the current ranking, not forecasting it; funding is sticky enough that repeating the present scores 67%. And p_stays_positive answered false on 30 of 30 while the truth was true on 17 — a refusal shaped like a forecast, and now the second independent replication of that exact behaviour after the 41-of-41 “no” on the cross-section card.

And one honest limit of the self-check. d_any_stretched was 100% correct while p(have) read only 0.352 — it under-rated a question it could in fact answer. That is a false escalation: it costs calls, not errors, and it is why the determinate arm clears p(have) > 0.5 on 84% rather than 100%.

What this is not. Nothing trades, nothing is held, no keys exist. The measured drawdowns are the funding leg only — they say nothing about liquidation, a venue failing, a bridge, an LST depeg, or a contract. Those are the risks that actually end carry books, none of them are in this data, and a monitor cannot manage them: only sizing can.

The carry cross-section, live

loading the funding cross-section…

—

A short receives funding; a long pays it. Hyperliquid carries a fixed interest-rate component, so funding sits at a floor of about 10.95%/yr — a perp long pays that essentially always, which is the mechanism behind the whole structure: be long via spot, be short via the perp.

Nothing here trades, and the drawdowns above are not reassurance. Carry is a short-volatility profile — steady small gains, rare large losses. A 90-day window with no crisis in it measures the gains and not the losses. The tail is not in this data. It never is.

Three tapes, one clock

waiting for the cross-section feed…

—

Nothing here trades. The relative-value leg does not clear its costs — the three move together ~76% of the time and the median best-minus-worst spread is 4.1bp over a minute against ~19bp for the two round trips a pair costs. These three are here because together they make a market question that has an answer, which is what the card above measures.

Where the money actually went

The same trades, at the same moments, run once with fees and once without. The difference is the drag — measured, not inferred from a fee times a turnover.

On the first recorded run of 50 decisions the answer was stark: net −0.50%, gross +0.06%, drag 0.56%. The timing was mildly positive and the fees alone made the run negative — the drag was 111% of the loss. That is why the tile above shows both numbers, permanently.

The fix that follows is to hold far more often and, when it does move, to move properly. A round trip costs roughly 10bp of the size traded, so a 0.2× position needs a 50bp move just to pay for itself. Positions too small to cover their own round trip are a way of paying to be almost flat. Hence two controls above: a dead zone of conviction inside which there is no view at all, and a minimum size below which a position is not worth opening. Both default from that cost arithmetic, not from a fitted run.

Replaying the identical 50 recorded answers — the model held fixed, only the harness varied — across five overlapping segments of the tape:

Fewer fills means less drag: 8.8 → 4.2 → 2.2 → 1.4, and 0.36% → 0.26% → 0.21% → 0.25%. That part is monotone, mechanical, and holds on every segment. The last two rows now give identical results because both saturate to the same behaviour — a plateau, which is what a mechanism looks like.

Building this found a real bug worth stating. The dead zone first mapped to flat. But exits are exempt from the deadband — getting out is meant to stay cheap — so every dip in conviction forced a full exit and the next reading paid to get back on. The setting meant to cut turnover doubled it, and the first live run came back worse. “No view” and “a view that flat is correct” are different things: the dead zone now means keep the position you have, and fills fell from 3.0 to 1.4.

And there is a trap underneath all of it. Gross edge here is about +0.06%, which is indistinguishable from zero. When the edge is zero, trading less always looks better, because the limit of trading less is not trading — which returns exactly 0% and beats every negative on the board. That is why do nothing is a ranked leg in the leaderboard below. Any change that reduces turnover has to beat it before it counts as an improvement rather than a retreat.

Another month — and the reversal did not replicate

208 days of hourly candles across BTC, ETH and SOL, pulled from Hyperliquid. Non-overlapping windows throughout. The original finding — big moves reverse — came from 3.5 days of one asset at one horizon, and it does not hold up as a general fact.

Across timescales on the full history, trailing move against forward move is essentially zero: +0.016 at 5m bars, +0.015 at 15m, +0.030 at 1h. The −0.179 that started this was a short sample at a short horizon. It was noise.

But splitting by month found something much better.

Seven blocks out of seven, all three assets agree on the sign. Under independent coin flips that happens with probability (¼)⁷ ≈ 6×10⁻⁵. Whether the market trends or fades is a regime, it flips, and it is market-wide — three assets are three readings of one underlying state, which is why pooling them roughly halves the error bar (±0.12 pooled against ±0.21 single-asset).

Two things immediately complicate it. The polarity does not persist: month to month the sign held 3 times out of 6, a coin flip — so last month's regime tells you nothing about next month's. And it is timescale-specific: over the last four weeks the 1h and 4h horizons read ≈0 while 12h reads +0.39 / +0.23 / +0.37, all three agreeing again.

So: is it tradeable? Estimating the pooled polarity on a trailing window and applying it forward — nothing from the future — the best of 30 configurations reached 60.6% ±6.7 directional accuracy (1h bars, 1-day horizon, 10-window estimate, gated at |r|>0.15), worth 45bp a window against a ~9bp round trip. That is z = 3.12, against an expected maximum of z = 2.61 from thirty pure-noise trials and a Bonferroni bar of 2.94. It clears, and only just. Worse, simply always fading at that same horizon scored 55.2% — so the adaptive part bought 5.4 points on n=216, with a standard error of 3.4.

The honest summary: one robust finding and one suggestive one. The cross-asset agreement was a single pre-specified test and it is overwhelming. The tradeable version is the best of thirty and sits right on the corrected significance bar, which is exactly where a result goes to be wrong. The only clean next step is to pre-register the horizon and test it forward on data that does not exist yet — everything else is re-reading the same 208 days.

What execution actually costs, measured

Everything below was queried live on 2026-09-19, not recalled.

This lab spent its whole life fighting transaction drag while charging one number: a 4.5bp taker fee. The obvious move — trade the spot instead, drop the leverage — is wrong twice over, and the right move was hiding in the same fee schedule.

The perp is the cheapest instrument in crypto, and it is not close. Spot on the same venue costs 56% more in fees and its best native book is 214× wider than the BTC perp’s 0.123bp. The wrapped-BTC spot pair there has $0 of 24h volume — there is no BTC spot market to trade. Venue-wide it is $8.9B of perp against $426M of spot.

And the lever was never leverage. This page already measured drag ÷ gross at 6.74 / 6.68 / 6.60 / 6.26 at 1× / 3× / 10× / 40×. Costs scale with size traded, so leverage multiplies the result and the drag by the same factor. Dropping it does not improve the economics per unit of exposure — it just risks less money at the same ratio. The lever is taker → maker, which is a 3× cut at the base tier and goes to zero, then negative.

And DeFi, which turns out to be the story

Round-trip cost through a Solana aggregator, five repeated quotes each, SOL → USDC → SOL. Everything included: LP fees, price impact, routing.

Below about $150k, on-chain spot beats the perp outright — and beats even the maker perp. Aggregated Solana liquidity for a major pair is genuinely deeper than the fee schedules suggest, and gas is dead as a cost: a swap is $0.0006 on Solana, $0.0024 on Base, $0.0004 on Optimism, and even Ethereum L1 at 0.0885 gwei is 3.5 cents — 0.003bp on a $100k trade.

Three things that table does not say. A quote is not a fill — one of the first attempts came back at 2100bp through a bad route before settling down, which is a real risk you manage with slippage limits, not a number you can average away. It is spot: no leverage and no shorting. And it is one pair on one chain at one moment.

The framing worth keeping: the cheapest venue measured anywhere here is itself a DEX. Hyperliquid is an on-chain order book on its own L1. The interesting split is not centralised against decentralised, it is order book against AMM — and AMMs win at small size while order books win at large, which is exactly what the shape of the two cost curves says.

The cost this book was not charging at all

A perp long pays funding. Ours never did.

Measured on Hyperliquid over 21 days: BTC funding averaged 0.1201bp/hour = 2.88bp/day = 10.5%/yr, and was positive — longs paying — in 96.2% of hours. book.mjs charged fees on every size change and nothing on the position held between them, so every long leg on this page has been flattered and every short paid, for the lab’s entire life.

On the 190-second fixture it is 0.01–0.25bp, so no measurement already on this page is overturned. But look at what it taxes. The conclusion drawn from the break-even table was “the only lever that moves that column is how long you hold” — and funding is the one cost that grows with exactly that. Holding is not free; it was only free here because the book forgot to bill it.

Who actually pays it. A strategy that flips long and short roughly equally is near-neutral to funding — it pays on the longs and is paid on the shorts. It is a tax on long-biased holding specifically, and a subsidy to short-biased holding. So the one place the instinct that started all this is dead right: a long-only buy-and-hold as a perp bleeds 10.5%/yr that spot simply does not pay. That is the honest case for the underlying, and it has nothing to do with fees.

The gate fires on markets — when the question has an answer

Two numbers on this page had never been reconciled. Now they are.

The ≥0.9 confidence gate is 66/66 perfect on determinate questions and fires 0 times in 342 on market questions. The standing explanation was that market questions are predictions and predictions have no determinate answer — which had never been tested, because no determinate market question was ever asked. Three tapes on one clock make one possible: which of these is strongest right now has an answer you can compute.

Six determinate and four predictive probes, same document, same call, 41 non-overlapping windows of 1m bars. Ground truth computed, never labelled.

So the 0/342 was about the questions, not the domain. Given a market question with an answer, the gate fires on seven in ten and is right 97% of the time when it does. That is the headline and it is good news for every cascade built on this pattern.

And the second row is the warning. Confidence alone let 40 predictive answers through at 30% accuracy. p_weakest_next cleared 0.9 on 20 of 41 windows and scored 19.5% — well below the 33% a coin-flip gets on a three-way choice. That is the same confidently-wrong failure already measured on questions about machines that did not exist, reproduced here in a new domain. A plain confidence gate is not safe on market questions.

The fix was already on this page. Asking “does the state contain what this needs?” as its own question, in the same call:

The self-check was perfect: 246/246 determinate above 0.5, 0/164 predictive above it. Mean p(have) 0.808 against 0.046 — a 76-point margin where answer-confidence managed 15. The worst determinate case (0.750) and the best predictive one (0.061) are 69 points apart; the two classes do not come close to touching. The 62-point margin measured earlier on a telemetry table replicates on live market data, and is wider here.

Compute-first replicated inside the same call. Five of the six determinate probes are a lookup and a comparison over figures the document prints; they averaged 89.3% at 0.908 confidence. The sixth, which asset is furthest from the average of the three, needs one subtraction the document does not carry — it scored 75.6%, and said so: confidence 0.642, gate fired on 5 of 41. The one question requiring arithmetic was the worst one AND knew it, with everything else held identical.

One number worth staring at. Asked whether all three would move together over the next hour, it answered no on 41 windows out of 41 — while the truth was yes on 82.9% of them. A constant “yes” scores 82.9%; it scored 17.1%. That is not a bad forecast, it is a refusal shaped like one, and the self-check flagged every single one of those answers at p(have) = 0.048. The model told us not to read them.

What this does not license. No position was opened and none should be. The relative-value trade dies on arithmetic before the model is consulted: the three majors move the same way ~76% of the time, the leader changes in 61–70% of windows, and the median best-minus-worst spread is 4.1bp over a minute and 14.7bp over fifteen — against ~19bp for the two round trips a pair costs. This is a measurement of the gate, not a strategy. And it is 3.5 days: one regime, as ever.

The first five minutes were a lie, and that is now fixed

The state document described windows the tape did not reach.

The metrics ring holds five minutes, but the decision loop started at twenty seconds and computed all three windows from whatever was in it. At the first decision the document said this, in these words:

Read together that is “price is at the top of its five-minute range, it just set a five-minute high this second, and volatility is exactly average” — three assertions, none of them measured, all leaning the same way. On the default ten-second cadence the first 28 decisions of every run were made against a document like that, and the 190-second fixture never reaches 300s at all, so every replay measurement on this page was taken in that regime.

A window is now reported only when the tape covers it. The document leads with TAPE SO FAR 47s and names the boundary; anything longer is left out rather than approximated; the volatility percentile is omitted rather than defaulted to a half; and the moving-average cross is absent until both means exist. The first call waits for the second window — sixty seconds — because every deterministic rule below keys off it. It does not wait for all three: five minutes of blank page is not honesty, it is just a blank page.

The oracles crashed on the fix, which is how the silent version was found. They had been reading those fabricated numbers without complaint. A rule whose inputs are missing now abstains — it does not vote zero, it is not offered as an option in the typed choice, and the tally counts it apart from flat. Six abstentions averaged as zeros would have shown Jev six rules agreeing that the tape was balanced. No data and a view that flat is right are different things, which is the same distinction the dead zone already makes one card below.

One nuance kept deliberately: a window that IS covered but perfectly flat reads zero, not null. That is a measurement of no dispersion, and collapsing it into “no data” would make a dead calm tape indistinguishable from a page that started four seconds ago.

So it was pre-registered, and it is running now

jev-lab-polarity-12h-v1 · committed 2026-09-18 22:29 UTC, in commit 54531db6, alone and before the code that evaluates it existed. Git holds the proof.

0 of 200 predictions — about 114 days to go at the measured rate

The rule, frozen. Pool the lag-1 correlation of non-overlapping 12h returns across BTC, ETH and SOL over the trailing 20 windows. If |r| ≥ 0.15, take the side sign(r) × sign(the trailing 12h move) — follow the move when the regime trends, fade it when the regime reverts. Otherwise no prediction. Success is accuracy above 50% at a one-sided binomial p < 0.05. No claim is made in either direction before n = 200, and there is no early stop for a good result.

What is disclosed, because it has to be. K = 20 and the 0.15 gate were the best of thirty configurations on the discovery data, where they scored 56.4% on n = 365. The forward test therefore tests that selected configuration as a whole — which is the point: a number chosen as the best of thirty is exactly the kind that needs data it was not chosen on.

And a secondary test that could run immediately: the same polarity, estimated from the registered three, applied unchanged to twelve assets never examined.

52.3% on 777 predictions is a one-sided p of 0.11 — not significant — and it loses money gross. The quartiles say something sharper than the total does: it is right on small moves and wrong on big ones, which is the exact inverse of the thesis that made the horizon interesting. The big-move card above is where the money was supposed to be.

The registration forbids changing the rule in response to that, which is the whole reason for writing it down first. Twelve fresh assets are a different cross-section, not a different month, so it is evidence and not the verdict. The verdict waits for n = 200.

One correction to the registration, published rather than edited in. Its own notes say the windows accrue at two per asset per day and that n = 200 takes about 33 days. Measured against the 208-day history, a 24-bar stride puts one window per asset per day and the gate passes 64.7% of them: 1.75 predictions a day, so n = 200 is about 114 days. The frozen file is left exactly as committed — a registration that gets edited when its schedule turns out inconvenient is not a registration.

Collection is a scheduled job, not this page: it runs twice a day, applies the frozen rule to whatever closed, and records the result. It calls Hyperliquid and never calls Jev — this measures the rule, not the model, and the model is why the rule was worth registering.

And the schedule runs on Cloudflare, because the GitHub one does not. GitHub fires schedule only for workflows on the default branch, and this surface's workflows live on its owning branch — so the first version of this was committed, tested, correct and accruing nothing. The trigger moved to where the surface already deploys: a Worker cron writing into a Durable Object, both declared in wrangler.jsonc, with no dashboard step and nothing outside this surface's own deploy. The counter above reads that record, and falls back to the committed file.

What that costs, stated plainly. A git-committed record is append-only in public history, and that is a real part of why a pre-registration is believable at all; a store the operator can write is not. So the split is deliberate: the registration stays in git — commit 54531db6, before any evaluating code existed — the Durable Object holds only the accumulating record, and the GitHub workflow is kept so that once it can fire it snapshots the same record back into git. Cloudflare is what makes the test run; git is what makes it auditable.

The only scoreboard that matters if the money is in a few windows

not enough price history yet.

Average return says do nothing wins. That is the right answer to the wrong question if the P&L lives in a handful of windows. Measured on 3.5 days of minute candles: the biggest 5% of hour-long windows carry 24% of all movement, and — the number the whole thesis rests on — a p95 hour-move pays 8.6× what a round trip costs, at any leverage. The drag is affordable. Being on the right side when it happens is the entire problem.

So: are big moves continuations you can ride into, or reversals that run you over? Non-overlapping windows, 3.5 days.

On this sample they reverse — and the bigger the move, the more strongly. A trend follower is offsides on 66% of exactly the windows that carry the money, capturing −8.5% of them. That is the opposite of the intuition, and it matters because Jev's stance criteria are trend-descriptive: “the tape is being bought and holding it” → buy. On data shaped like this, the framing itself is the losing side.

An error worth publishing. The first pass of that table used overlapping windows and had a momentum rule at 75.7% accuracy over 4,844 of them. Non-overlapping, that rule fires on four windows. Adjacent overlapping windows share 59 of their 60 minutes: it was one trend counted hundreds of times. Every figure above is non-overlapping, and the capture metric enforces it in code.

And the caveat that outranks all of it: 3.5 days is one regime. That mean reversion won here is a fact about this sample, not about markets — which is exactly why the polarity is not hardcoded anywhere, and why the honest next step is the same test on a different month rather than a rule change.

Stream B — thirty floats, and nothing else

A second stream running beside the first, on the same ticks. It is sent thirty numbers, one per line. No units, no labels, no mention of a price, a market, or what any of it is for. It is asked one thing: “The next value in this sequence will be:” — and max leverage is slammed in whichever direction it says.

It deliberately breaks every rule the rest of this page obeys, which is why it is worth running: the contrast is the experiment. (Jev cannot return a free float — the primitives are choice, score and noul — but a score over an ordered ladder is a continuous number, so thirty in and one out survives intact.)

Three runs, ~390 windows across 3.5 days of minute candles: noise. Normalising the floats into returns did not rescue it. Worth noting what it did instead of guessing — it hedged to the middle rung, forecasting a mean of 0.7bp against actual moves averaging 4.0bp. Asked to predict, it declines, the same way it declined on six-hour windows. That is the honest answer to an unanswerable question.

But the accuracy turns out not to be the deciding number. Trading a per-bar forecast has a break-even accuracy set purely by arithmetic: a full reversal trades twice the size, so it costs 2 × cost × size, while a correct call earns the move × size. Leverage appears on both sides and cancels. It multiplies the edge and the fees by the same factor — a magnifying glass, not an engine.

The only lever that moves that column is how long you hold. Traded every minute at 40× on the real forecasts, the leg returned −75.7% over 150 minutes: 37 fills, 2840× turned over, and 70 points of the 76 were fees. The configurations that did not lose were the ones that barely traded — three fills in 150 minutes — and their gains are one held position getting lucky at 40×, not a strategy.

So stream B stays on the board as what it is: the control that shows what breaking the compute-first rule costs, and the demonstration that at this cadence the fee structure decides the outcome before the model is even consulted. The live stream runs at ten-second buckets, where the break-even is not merely high but unreachable.

Does more leverage outrun the fees?

BTC on this platform caps at 40× — the only asset there that does. The same 50 recorded answers, replayed at every cap, each run twice so gross and drag are exact.

No — and the reason is arithmetic, not opinion. Costs scale with the size traded, so leverage multiplies the gross result and the drag by the same factor: gross scaled 42.4× from 1× to 40× while drag scaled 39.4×, leaving drag-as-a-share-of-gross essentially flat (6.74 → 6.26). Leverage is a magnifying glass held over whatever the edge already is. Held over a negative one it magnifies that.

What it does change is ruin. A cap of N× is wiped out by an adverse move of 100/N percent — 33% at 3×, 2.5% at 40×. The recorded tape's worst move inside any five minutes was 0.16%, so 40× looks survivable on this tape and would not be on a worse one. The slider goes to 40 because that is the real platform limit; the book models the liquidation because a leveraged demo that cannot be ruined is lying.

Giving him his own history

He had been deciding a position every few seconds with no idea what he decided last time, how long he had held it, or what it had earned since. In the dungeon the same gap had the same shape — he walked into dead ends and gave up in them.

The journal gives him his last eight decisions, what each one went to, and — the column he has never had — what the position has earned on the move since it was taken. Two arms walked the identical tape with identical book logic; the only difference was whether that block was in the document.

His decisions barely moved. The ladder scores track each other almost exactly — 4.6/4.7, 4.9/4.7, 5.2/5.3 — and net, fills and turnover are unchanged. But his own sense that the decision is decidable rose by 0.13, and it rose by 0.16 when the rule-based strategies were added earlier. Twice now, extra context has moved the self-check without moving the behaviour.

That is worth stating as a limit rather than a win. The self-check appears to track how much context it has rather than how much that context helps — so it is a good detector of a missing value and a poor proxy for decision quality. It is still the right thing to gate on, and it is still the only number here that separates an answerable question from an unanswerable one by 62 points. It just should not be read as a scoreboard.

Leaderboard

—

Six fixed rules run on the identical ticks at identical costs — MA cross, mean reversion, breakout, momentum, taker flow and funding carry — and Jev is shown what each one currently says before he decides. Their thresholds are textbook defaults, stated in the code, and deliberately not tuned: picking them to make a run look good is the exact failure this page exists to avoid. Two of the legs are not strategies but controls — the average of the rules, and whichever rule is ahead on past performance only.

Continuum or quanta? score is both

Why the exposure ladder is a score and not a choice. Six real states, both questions in the same call.

score takes an ordered array of rungs and returns the expectation over the distribution across them — so the ladder is discrete, which is what makes the ceiling enforceable (it cannot return a rung off the end, so it cannot ask for 50x), while the output is continuous. A choice over the identical seven quanta throws the ordering away and takes the argmax: it answered the extreme −3x on five of six states where the ladder graded them −2.83x to −1.72x.

One thing this page deliberately does not do: scale the target down again by the score's confidence. The score is already the expectation over the whole distribution, so a hedged read has already been pulled toward the middle rung — which is flat. Scaling again would count the same uncertainty twice. A bimodal read lands near flat for the same reason, which is the right size for it.

Doing the arithmetic for him

Every metric in the first version was a rate — how fast, how far, which way. None of them said where.

Rates alone cannot tell selling into a five-minute low from selling into a five-minute high, which is most of what a person means by reading a chart. So the page now computes the levels too — moving averages, the distance from them in standard deviations, position in the recent range, distance from and age of the recent extremes, and where current volatility ranks. All of it arithmetic done here so the judgement does not have to do it.

Six questions about the tape whose answers were computed, asked of both documents over sixteen windows — 80 paired items each.

Paired over identical states, a sign test gives rich won 30, thin won 2, tied 48 — z = 4.95. A sixth probe was thrown out: its answer never changed on this tape, so a constant guesser scores 100% on it for free and it measures nothing.

Two things this cost, both worth knowing. Writing the volatility line as “calmer than 20%” sent that probe from 80% to 40% — answering “is volatility high?” then needs an inversion, which is arithmetic handed back after all the trouble of handing it over. And shipping both a volatility ratio and a volatility percentile cost another 12 points: two views of one fact is reconciliation work. One line, pointing the way the question points.

What it did not do is make the future more knowable. Over the same sixteen windows the is this decidable? answer moved 0.256 → 0.237, and are the figures present? 0.831 → 0.816. Better informed, not more clairvoyant — which is the whole distinction this lab is built around.

The most interesting number on this page

Four availability questions, one real state document, one call.

That is one model, one state, four phrasings — cleanly separating the data is here from this is not decidable. It is not a wording artefact, and it is the reason the live is this decidable? tile above sits where it sits and is never allowed to gate anything. A trading demo that hides this number is hiding the only honest thing it knows.

What this lab is for

And what it deliberately refuses to do.

Jev is never asked what happens next. Asked to call direction on 111 six-hour windows it returned probabilities spanning only 0.36–0.60 and never once cleared 0.7 — which is the honest answer, and the reason this page asks it to classify what is happening rather than to forecast.

That distinction is worth more than it sounds. On five identical states, asked “what should the position do?” it answered hold five times out of five at 0.46–0.79 confidence. Asked “which stance matches what the tape is doing?” it answered sell five out of five at 0.70–0.96 — and taker skew on every one of those windows was between −0.89 and −0.98, so the tape really was being sold hard. Weighing a trade is a prediction, and it declines to make those. Describing what is in front of it is a judgement, and it makes those confidently. So the page asks for the stance and the harness pays the cost of acting on it.

Every decision also carries a self-check: does the state contain what this needs? Reading the action's own confidence separated answerable from unanswerable by 0.0 points in measurement; asking the question separately separated them by 62. When the self-check says no, the lab holds and says so rather than acting on a confident-looking answer.