What the evolved routers kept, dropped, and invented

Every earlier result came from generated topologies. That leaves an obvious objection: the evolved routers were bred in a world that might simply suit them. So the last run inverted the advantage. lnd's defaults were tuned by years of contact with exactly this graph; the evolved routers had never seen a real one. A hundred payments were sent from the network's highest-degree node — 2,015 channels — across five liquidity seeds under both bimodal and uniform hidden-balance regimes.

Read the two columns together and the story sharpens. On synthetic bimodal corpora lnd struggles to deliver at all, scoring 0.3–0.5 success; on the real graph it is a competent router at 0.790. The success gap compresses on lnd's home turf. The efficiency gap widens.

That is the opposite of what an overfitting story would predict, and it points at the mechanism. A well-connected mainnet source has an enormous number of plausible paths, which is exactly the setting where a router that remembers what it has already disproved stops re-probing, and a router that lets its memory fade keeps paying to relearn it.

The first real run treated lnd's pathfinding as a set of knobs and let the optimizer turn them: which probability estimator to use (apriori or bimodal), what a failed attempt should virtually cost, the floor on acceptable route probability, the estimator's own priors and half-lives. Four hundred evaluations, thirty-three iterations, sixteen distinct proposals.

Nothing beat the defaults. The best candidate on the validation aggregate was the lnd defaults, at 0.3647 — and on the sealed test set, 0.3430, which is to say the baseline. Two bimodal specialists survived on the Pareto front by winning individual examples, and most bimodal variants scored far below the seed. Within this paradigm's parameter space, the shipped defaults are locally robust.

What made that finding load-bearing rather than disappointing was a control experiment running beside it. A deliberately naive router — roughly 300 lines of cheapest-path Dijkstra with a per-payment failure blacklist, no probability model at all — was scored against lnd's full production stack on the same corpus. It won or tied 16 of 16 examples, at 1.9× the success rate and 2.3× fewer attempts. On corpus v2 the composite objective came out 0.547 against lnd's 0.393, a 39% margin.

Which is what the rest of the project did. The evolvable unit became a whole Go file behind a paradigm-free interface: gossip view, local balances and per-attempt feedback in, a route out. Nothing in that contract mentions Dijkstra, mission control, or probability estimators.

Two champions of record came out of this rather than one. hb1 (872 lines) is the hard-regime specialist: it holds the best score on the sealed bimodal test at 0.586. mx_c3 (1,525 lines) evolved from it on a mixed corpus and is the better generalist — a statistical tie on the hard test (0.583) and a clear win out of distribution (0.581 against 0.545), for the best combined average of anything tested. A third frontier member, hb2, is strictly dominated by mx_c3 and has been retired. (§11 narrowed this, and the same-day adjudication settled it: on the original tier set hb1 beats mx_c3 nowhere, while mx_c3 takes split-test unanimously (8/0, p=.008) — the one tier where hb1 cannot even beat lnd. The title is defended; hb1’s family-tier edges do not transfer (exp-020).)

Three properties matter more to us than the margins:

Reproducible. The hard test was rescored five times for both lnd and hb1. Standard deviation 0.00000 — identical to four decimals every run. There is no wall-clock nondeterminism in these numbers.

Exploit-clean. The simulator seals hidden liquidity behind a view interface, and an adversarial audit of that seal (§21) found and closed a real escape. Both champions were validated after the seal, with zero uses of any exploit path.

Held out, not fitted. The sealed test set is untouched until a champion is declared; the out-of-distribution corpus adds Barabási–Albert scale-free graphs of 800 and 1,500 nodes with log-normal capacities that no champion trained on; the mainnet graph is a different kind of object altogether.

The evolved cost function is a risk-adjusted Dijkstra over these probabilities rather than lnd's fee + attempt_cost / P(route), and mx_c3's retry policy is adaptive: when an amount fails, it tries a smaller one along the same corridor instead of writing the corridor off. Both are downstream of the same decision to represent knowledge as bounds.

The two champions came out of a long lineage: a 400-evaluation breakthrough run, then a 500-evaluation continuation seeded from its 872-line winner. Every reflection prompt in that continuation had to carry the whole body of the incumbent. So exp-011 asked the cheaper question: do the ideas transfer without the code? A fresh run, code_gen2, was seeded from the small original ~380-line router, and the discovered structure was supplied only as prose in the background prompt — the bimodal prior, per-directed-channel liquidity bounds in place of time decay, retry-at-lower-amount, and a note to stay lean. Four hundred evaluations, no other help.

Insight transfer works, and it is faster. The run accepted 31 candidates in 31 iterations against the giant-seed run's 17 accepts in 500 evaluations; small prompts mean cheap, frequent mutations. The router it produced — call it gen2 — lands within one to two percent of the champions on every held-out tier, and matches them exactly on mainnet efficiency at 2.3 attempts per payment.

And it stopped where they stopped. gen2 sits between hb1 and mx_c3 out of distribution, a hair under both on the hard test, a hair under on mainnet. Three lineages bred independently — one from failure traces alone, one continued from a champion, one from prose — now occupy a band 0.014 wide.

Two inventions the simulator never paid for

gen2 is not a copy. It arrived at the same paradigm family — explicit bimodal prior, lowerOK and upperFail beliefs with evidence counts, risk-adjusted Dijkstra, retry-at-lower-amount, no time logic anywhere — and then added two mechanisms neither champion has:

In-flight liquidity reservation. reserveRoute and releaseRoute track what concurrent MPP shards have already committed on its own first-hop channels, rolling settled amounts into a spent ledger, so two shards cannot double-book the same outbound balance.

Weakest-edge failure attribution. On an ambiguous TemporaryChannelFailure it blames only the least-evidenced hop on the route instead of penalising every hop, which keeps hard-won evidence about the innocent channels intact.

Both are sound engineering. Neither moved the aggregate by a measurable amount, because nothing in the current simulator rewards them: shards settle sequentially, no exogenous traffic contends for the liquidity a reservation would protect, and the splitting pressure is mild. They were carried along neutrally — which is the clearest possible sign that the selection pressure, not the search, has run out.

An environment that forces the split

The corridors corpus is a topology built to leave no other way through. Between source and target run eight to sixteen parallel corridors of deliberately unequal capacity — one fat one, then rungs each at most half the size of the one above — with the tier enforced structurally by the channel into the target, so the fattest corridor is a hard ceiling on any single shard and the sum of the tiers is a hard ceiling on the payment. Each file opens with two cheap probes that seed corridor knowledge, then asks for one payment larger than that ceiling. A control run pinned to max_parts = 1 fails all forty files.

Mandatory splitting is not the interesting part. Unequal splitting is. Halving an above-ceiling payment yields shards only the fat corridor can carry, so the ladder of halves the champions evolved has to give way to shards sized to the corridors that actually exist. That is what exp-010 was built to ask: does joint route-set planning — choosing routes and shard amounts together, min-cost-flow style — emerge once reactive laddering has to pay for itself?

One thing about this corpus was true before any evolution ran, and it is worth stating on its own. lnd is good here. Its production divide-and-conquer MPP completes 0.958 of the held-out payments for the second-best objective on the tier — the first environment in this project where the production stack outranks part of the evolved lineage. It spends 23.4 attempts per payment to do it.

The mechanism emerged three times, at three depths

Each arm ran the same corpus, the same 400-evaluation budget and the same seed; only the model doing the reflecting changed. Each produced a router that plans route sets rather than shards in isolation, and they line up in order of how much thinking went into every proposal.

codex, one-step lookahead with reservation. Its 976-line winner derives unequal split candidates from known bounds and estimated corridor sizes rather than from halves, and for each candidate shard it reserves the route, plans the next shard against what is left, and scores the pair jointly. In-flight liquidity reservation — invented speculatively by two earlier lineages and rewarded by nothing (§05) — is finally load-bearing.

Opus 5 at medium effort, corridor-sized shard sets up front. No lookahead: it commits to a whole set of unequally sized shards before dispatching any of them.

Opus 5 at default effort, persistent parallel flow plans. The deepest machinery the project has produced, at 1,931 lines — well past the complexity wall of §21. A flow plan survives failure, dropping only the corridors that evidence actually contradicts; dispatch is concurrency-first, filling the shard budget with the largest believable amounts before it ever ladder-searches; and planning is residual-aware, decrementing a shared local-balance budget across the shards still to send.

The first statistical tie, and what it cost

On the corpus it was bred for, the Opus-default arm caught the champion. +0.005 on split validation with a higher raw success rate, 0.958 against 0.917, and a deficit on split test small enough to be noise (−0.035 at p = 0.07). Nothing else in this project has closed that gap on any tier. It also beats the codex arm clearly on the corpus both were bred for, 0.841 against 0.810 held out, and edges it on mainnet.

Then it leaves the corridors and falls over: 0.303 on the sealed hard test where mx_c3 scores 0.583. The cause is legible in its own source. The adaptive fail budget it tuned for corridors gives up after about seven attempts, and on hard bimodal networks mx_c3 spends 10.8 and succeeds at 2.4× the rate. Knowing when to stop turns out to be a property of the environment you learned it in.

Reflection quality beat reflection throughput

The medium-effort arm was the controlled version of the obvious question: at a fixed evaluation budget, is a slower and more deliberate proposer worth waiting for? It matched codex's throughput — one to two minutes a proposal against the default arm's five to eight — and finished hours earlier. It also produced the weakest router of the three on held-out data, 0.743 on split test, while posting the best validation score of the family at 0.874 against the default arm's 0.798.

That is a textbook validation overfit, and the sealed sweep caught it exactly as the method is designed to. At a fixed number of evaluations, reflection quality wins. At fixed wall-clock, where medium's roughly fourfold iteration rate would buy about twice the evaluations, the question is still open — and deliberately unrun.

What the arena changed, and what it deliberately did not

Three couplings moved, all behind one scenario flag. Shards hold rather than settle: a shard that traverses successfully locks liquidity along its path, and the whole set either settles together or releases together, which makes failed MPP genuinely atomic and removes a fidelity distortion the simulator audit had flagged. Holds contend: sibling shards and background traffic see availability net of what is held, so a router that probes a corridor physically reserves it and two shards can no longer spend the same satoshis. The world keeps turning: background traffic now runs on attempt boundaries at thirty virtual seconds each, so a twenty-attempt ladder watches ten minutes of corridor churn while a plan committed up front commits before the world moves.

One thing was left alone on purpose. Per-attempt failure feedback is unchanged. Batching feedback until a whole shard set resolved was considered and rejected: on mainnet each shard's failure is observed as it happens, so denying that information would be less realistic, not more, and it would break the interface that keeps all seven routers comparable. The honest cost of sequential probing is time and reservation, and those are what the arena now charges. With the flag off, every legacy corpus produces byte-identical results, so nothing on this page was invalidated by the change.

The subsidy was real, and the baseline proves it

The most interesting result of exp-010b arrived before any evolution ran. Rebuild all seven routers against the new tree, score them on the atomic corpus, and the ranking is not the one we have been reading for eleven experiments. lnd falls from second place to last. On the non-atomic corridors corpus its production MPP was the second-best objective on the tier (0.837); here it scores 0.338, spending more than a hundred attempts per payment to get half of them through. Nothing about lnd changed. The bill for sequential probing did.

The champions keep the top of the table, but the shape underneath them is new. opus1 — exp-010's persistent-plan router, which collapsed off-corpus and had never seen an atomic shard in its life — is statistically indistinguishable from mx_c3 on both atomic tiers (−0.013 at p = 0.73 on validation, −0.019 at p = 0.29 on test), while the shallower planners stay significantly behind. Deep joint planning was always worth something. It had just never been in a market that paid for it.

The tempering check written down in advance also passed: mean success across routers sits between 0.45 and 0.57 with objectives from 0.29 to 0.44 — hard, not collapsed, real headroom in both directions — so the churn parameters stood and evolution ran on them unmodified.

Two arms, and a hybrid that had not appeared before

Both proposers got 400 evaluations on the atomic corpus, with the arena's economics spelled out in the background prompt and the hold ledger added to the exploit grep. Both produced exactly the mechanism family the arena was built to elicit, and they produced it differently.

Opus 5 at default effort re-derived something close to honest min-cost flow in 987 lines: corridors enumerated once per plan with per-edge reservations, exclusion by whole edge set so shards cannot silently contend, shard sizes drawn from believed capacity, residual planning that reuses known bounds. Drift bred it one mechanism the family had never shown before — repeated whole-plan failure relaxes hard bounds slightly, so a churning network can be re-probed instead of being written off as permanently unroutable.

codex/gpt-5.6-sol built a hybrid, 1,031 lines, and it is the first of its kind here: the codex lineage's cross-payment network memory, keyed by a network hash and carried between payments, fused with up-front route-set planning. makePlan and planOnce build a shard plan against a per-edge reservation ledger, and the edge probability function prices each edge with its own reservations folded into the amount, so a plan cannot lean on the same corridor twice. Cross-payment belief and within-payment planning, in one router.

Right architecture, wrong economy

The Opus arm's failure is legible in a single column that is not in the table. On atomic test it spends 57.5 attempts per payment, against mx_c3's 12.6 and the unevolved challenger's 23.5. The relax-and-re-probe loop that drift bred into it converts tolerance for a moving network into attempt burn, and the objective's attempt penalty — plus the extra drift each attempt invites — eats the success it buys. Evolution polished the right architecture into the wrong economy.

There is a sharper negative result hiding inside that. Four hundred evaluations of evolution on the atomic arena produced a router that is worse on the atomic arena (0.391) than exp-010's opus1, which never saw atomic semantics at all (0.425). Held shards, contention and attempt-time churn make per-file scores swing, and minibatch acceptance inherits the swing. The resolution caveat registered during exp-010 is still binding, in a new form: this corpus fixed the quantisation and introduced variance.

The first challenger without a cliff

The codex arm did not win either. It also did not lose anywhere, and that is new. Every previous challenger in this project bought its home-corpus strength with an off-corpus collapse — the exp-010 Opus arm at 0.303 on hard against mx_c3's 0.583, opusmed1 the same, drift1 short on all four tiers. atomic1 has no collapse tier. It is statistically indistinguishable from the champion on hard (p = 0.75), on out-of-distribution topologies (p = 0.75) and on mainnet, where it lands within a thousandth of mx_c3's objective.

And it gets there with 1.6 attempts per payment on mainnet, below the champions' 2.3 and the lowest figure this project has recorded on the real graph. The sign test on that tier reads p = 0.039, which sounds like a loss and is not: it reflects hair-width per-file deficits that are consistent in direction and negligible in size, summing to a delta of −0.001. Breeding under drift plus atomic commitment produced robustness where every earlier environment produced corpus-pinned constants.

The regime nobody had measured

Every scenario file in this project starts a router with an empty mission control and empty candidate beliefs. That cuts both ways. It means the champions' 8.6× attempt advantage — the perfect-channel figure §12 has since retired — was earned with no more history than lnd had, which is the fair version of the comparison — and it means the regime a real node actually lives in has never appeared on this site. The field observation that prompted the experiment is that mission control's weights matter enormously on a network of unbalanced, unreliable nodes, that a new node has none, and that the fix might be to serve cached weights over an API so a fresh node can hot-load instead of probing from scratch.

Three questions follow: how fast does each design get cheap, what is imported knowledge worth, and how stale can it be and still help.

Part 1 — the warmup that never starts

Payments inside a scenario file run in order against one mission control and one set of candidate beliefs, so the attempt count at payment i measures what the first i−1 payments taught the router. The raw curves are confounded, because payment 10 is a different payment from payment 1. The clean read normalises each router against the champion on the same payment, and compares the start of a batch to its end.

lnd's mission control does not warm inside a realistic batch. Its disadvantage does not shrink with experience: on mainnet it grows from 4.7× to 11.9× as its absolute attempt count climbs from 10.1 to 31.2, and on the hard corpus it is flat. Ten payments of history buys nothing measurable. This is the empirical form of the field complaint, and it is worse than the complaint — the warmup is not slow, it has not started.

The champions' advantage is a prior, not a history. mx_c3 spends 2.4 attempts on its first three mainnet payments, before it has learned anything at all, and 2.6 on its last three. That is encouraging for the hot-load idea and it also reframes it: the thing worth shipping to a fresh node may be the bimodal prior and the interval machinery, not a cache of somebody else's observations.

Exactly one router demonstrably learns. atomic1 halves its ratio to the champion across the hard batch, 1.56× to 0.73× — the clearest within-batch learning signal in the family, and consistent with its being the only router in the field that carries a belief map from one payment to the next. Both Opus-lineage routers build a fresh router per payment and show no such improvement. The lineage split is now visible in the measurements rather than only in the source.

Part 2 — the method failure worth publishing

The obvious instrumentation is an unscored warmup phase: run N payments through the identical code path, then score the same batch. The first sweep measured the wrong thing, and the failure is the useful part. Warmup payments are real payments. They teach the router and they drain the network the scored batch then has to use. Across N = 0, 25, 100 and 400 on mainnet every router got monotonically worse — objective 0.79, 0.65, 0.43, 0.20 — and at 400 the whole field collapsed to a 22% success rate, where lnd “led” on objective purely by abandoning a dead network faster than anyone else. That is depletion, not the value of a cache.

The control that separates them is a liquidity snapshot taken before the warmup and restored after it. Be precise about what that arm then measures. The network is fresh again, but the router's beliefs describe the drained network it just finished exploring, so this is knowledge about a state that has since been completely churned — a maximally stale cache, which is the worst case for a weight-serving API rather than a fair model of a fresh one.

Three failure modes, each legible in the attempt counts

lnd thrashes. Its attempts climb from 19.8 to 32.4 while its success falls from 0.79 to 0.35. Mission control's pair entries are permanent zeros on this tier — no clock section, so decay never fires (§00) — so a stale blacklist keeps steering it onto fresh-looking routes that are no better, and it never gives up.

The champions abandon. Both collapse to 0.6 attempts per payment at 36% success: they quit almost immediately. Their upperFail bound is a hard zero, so a stale bound declares a perfectly good channel dead, and enough dead channels make a live payment look hopeless before it is tried.

atomic1 shrugs. 0.790 to 0.775 — a 2% degradation against the champions' 56% and lnd's 67% — at a nearly unchanged two attempts. Its persisted bounds clamp to a 0.012 probability floor instead of zero, so stale evidence makes a channel unattractive rather than forbidden, and one retry is enough to correct it. The scope-split that produced this behaviour was bred in the atomic arena (§07) for entirely different reasons.

Part 3 — a null that indicts our own simulator

The staleness-gap arm holds depletion constant — an identical 25-payment warmup in every arm, no restore — and varies only an idle gap of 0, 600, 3600 or 21600 virtual seconds, during which background traffic runs. Six virtual hours of churn changes nothing, to three decimal places, for any router: lnd stays at 0.544 and 24.6 attempts, mx_c3 at 0.614, atomic1 at 0.650.

The manipulation check, run before anyone was allowed to believe the null, passes cleanly: background payments sent scale 700 → 720 → 820 → 1420 across the four arms, exactly the prorated volume the idle advance promises. The knob works. The world does not move enough for it to matter.

And that is the finding, because the reason is a simulator defect. Only about 18% of background payments settle — the traffic engine sends naive fee-optimising payments that mostly fail, and a failed payment moves no liquidity — so our exogenous process is roughly five times weaker than its configuration implies. Against a 12,161-node graph, several hundred mostly-failed payments never touch the corridors a scored payment needs.

Part 4 — a stranger's knowledge is not worse

The vantage arm scores from a well-connected mainnet source and warms from either that same node or a degree-31 stranger, with everything else matched — same eighteen files, same 25 warmup payments, same liquidity restore — so the only variable is who gathered the knowledge. Nobody is hurt by a stranger's observations, and lnd is helped: 0.155 to 0.176, with its attempts falling from 3.0 to 0.8. atomic1 is identical to three decimals (0.209 both ways) and mx_c3 is within noise (−0.005), which is the expected result for per-directed-channel bounds — facts about a channel carry no trace of who observed them.

lnd improving is the surprise, and it sharpens the vantage story rather than confirming it. Most of mission control transfers, because a failure at a remote relay records the pair (relay, target) with no reference to the observer. The entangled remainder is the pairs crossing your own local channels — precisely the pairs every one of your payments must traverse. Warming from its own vantage fills those with stale zeros it cannot decay away on this tier, and it thrashes around its own poisoned first hop. A stranger's warmup cannot touch them, so it teaches the transferable part and leaves the critical part clean.

So the practical answer to what a weight-serving API should serve is narrower and more interesting than vantage-independence suggested: serve remote-pair observations, and never import observations about the consumer's own local channels. Those are the ones a node can cheaply measure for itself, the ones whose staleness is most damaging, and the only genuinely vantage-bound part of mission control.

Verdict — no hot-cache regime, and a limit we have to state

Across every arm — knowledge with depletion, stale knowledge with the network restored, a stranger's vantage, and 100 small valid probes at 2% and 10% of the scored amounts — no amount of warming ever lifts any router above its cold-start score, and mission control never approaches the champions. The probe arm is the strictest version, since what it learns stays true when it is used, and nobody gains there either: mx_c3 goes 0.791 → 0.768 → 0.653 and lnd 0.694 → 0.664 → 0.597 as the probes grow. lnd's attempts do fall at 10% probes, 19.8 to 15.9, which is the only genuine warming signal anywhere in the experiment, but its success falls faster.

Two mechanisms explain the negative and they are worth separating. The champions have nothing to learn — they are within noise of their asymptote on payment one, so warming can only subtract, by spending liquidity or by going stale. And lnd cannot learn fast enough for it to matter: 100 observations on a 12,161-node graph is roughly 1% pair coverage, recorded as permanent zeros, so the marginal observation is about as likely to poison a future route as to inform one.

Why this needed running at all

lnd ships a bimodal estimator whose hypothesis is the same one the champions exploit — channel funds sit at one end. It is not the default, and its scale_msat is an absolute amount defaulting to 300M msat. Our generator draws balance fractions with mean 5% of each channel's capacity, so the scale that matches this environment is 5% of a typical channel: 100M msat on the hard corpus with its 2M sat channels, 150M on v2 with its 3M sat channels. The staged baseline used the raw default. The closest analogue to the champions inside lnd had therefore never been given its best shot — the cheapest outstanding experiment in the program, and a prerequisite for any upstream conversation.

No scale beats lnd's own default

Not on either tier, and none comes within 0.19 of the champion. The environment-matched scale is not even the best bimodal setting — it is among the worse ones, 0.261 on hard against the 300M default's 0.280. So “the paradigm is the lever, not the knobs” is now tested against lnd's closest analogue, given the scale this environment actually calls for, and it holds.

How it fails is the finding

Read the success and attempt columns together on the hard tier. Bimodal raises success, 0.421 to 0.478, and simultaneously more than doubles attempts, 30.9 to 77. A better liquidity prior makes lnd more willing to keep trying — it correctly believes some route might still work — so it completes more payments at a much higher price. Under an objective that charges for attempts, that is a net loss.

What it does not do is change what lnd retries. findPath takes the amount as a fixed argument and only halves when path finding fails outright, which on a large graph almost never happens, so with any estimator lnd keeps retrying the same amount over different routes. The champions read their upperFail bound and retry a different amount. A better prior improves route ranking inside a broken retry strategy; it cannot supply the missing one.

The arm that could not be built before

§08 asked what a warm cache is worth and could not answer. Every arm it could construct bought its knowledge with payments, and payments drain the corridors they teach about, so one arm paid in depletion and the other in staleness. The thing the actual proposal describes — knowledge arriving over an API for free — was unconstructible.

--import-weights constructs it. For each of ten sealed hard-tier files a different source node runs the same network and exports what it saw; each consumer then runs the original file twice, cold and served. Same graph, same liquidity seed, same payments. The only variable is whether the consumer was told anything.

The mechanism, after three wrong guesses

Splitting the observation stream turns a scoreboard into an explanation. Successes help every consumer: lnd +0.003, mx_c3 +0.028, atomic1 +0.038. Nobody is hurt by being told what worked. Failures divide the field — they help the interval routers and they are the entirety of lnd's loss.

Why took three attempts, and the first of them was published on this page before it was checked. It is recorded here rather than quietly replaced.

Not an amount-blind penalty. The first version of this section claimed lnd files a failure as a pair penalty that suppresses the corridor for every payment size. probability_apriori.go:363 returns the unpenalized prior whenever the amount is below the recorded failure amount, so lnd's estimator gates on amount correctly. The claim was false.

Not node-level contagion. lnd folds every pair result into a node-level prior used for all of that node's untried channels — a keying collapse onto nodes, which the “761 edges, 761 pairs” check never ruled out. Disabling that aggregation leaves the loss almost untouched, −0.046 to −0.038.

Not staleness. Failures exported by a server that sends a single payment, and so barely perturbs the network it reports on, cost lnd nothing at all. That looks decisive until you count them: 232 against 2,808. A size-matched random subsample of the stale set costs −0.003. At equal volume, stale and fresh are the same.

What survives is volume. Each imported failure blocks one directed edge at or above its amount, and server and consumer draw their amounts from the same distribution, so the bounds land exactly where the consumer is about to send. At 232 observations few corridors close and nothing happens. At 2,808 across a 761-edge graph, lnd's pathfinder finds the amount it wants blocked almost everywhere, and its only available response is to route around — onto longer, worse paths. Attempts rise, success falls.

The interval routers receive the identical removals and turn them into instructions. An imported upper-fail bound of X tells mx_c3's shard ladder to try (X−1)/k: the bound does not merely delete an option, it names a smaller one that should work.

So the thesis survives in a sharper form than first written. lnd's estimator does not ignore amounts. Nothing downstream of it can act on an amount bound — path finding takes the amount as a fixed argument, so knowing that at least X fails on an edge can only subtract routes and never resize the payment. That is the same missing piece §09 found from the estimator side, and the two now converge on one patch rather than two observations. The patch was built in exp-021, and this is the half that failed: three ways of letting a bound resize the next attempt all reduce to the geometric descent lnd already runs, for no measurable gain (§14).

What the API should serve

Neither side's internal state can be served. Mission control keeps a decaying penalty history keyed by the observer; the evolved routers keep an interval with an evidence count. Both, however, are derivable from one stream of (from, to, chan_id, amount, success, time). So serve observations, not weights — serving either side's weights would force every consumer into that side's probability model, which is the difference between an API only lnd can use and one a competing design can use too.

Two rules follow, both measured rather than argued. A consumer must store failures as amount bounds to benefit from them, so an API that serves failure observations to lnd as it stands makes lnd worse; either serve such consumers successes only, or teach mission control to keep FailAmt as a bound the retry loop reads. And never serve observations about the consumer's own channels — 43% of what a node observes is about its own channels, so a naive server ships nearly half a payload that must be dropped.

Two things found on the way

The champions could not consume anything at all. Nothing in the router contract ever asked a candidate to accept third-party knowledge, so no evolved router implements it. This experiment therefore also produced importer variants of mx_c3 and atomic1, each its ancestor plus one method that routes every observation through the same belief update a real attempt makes. Both score identically to their originals when cold, so the only thing that changed is the capability.

Three predictions failed here, and the record keeps them. The first reached this page before it was checked; an independent review caught it by reading the estimator rather than the summary. The pattern is worth more than any one of the errors: in each case a real measurement stood while the mechanism story attached to it did not. Measurements in this project are more trustworthy than the explanations bolted onto them, and an explanation should be checked against the code it describes before it is published.

The circularity, stated plainly

sim_liquidity.go draws hidden balances as ExpFloat64() * 0.05 of capacity; atomic1's low mode is exp(−x/0.055); the mainnet tier overwrites the real balances with that same draw. Every number above therefore sat on a distribution we wrote ourselves, and “the champions beat lnd” could in principle have meant only “the champions memorised our generator.” This is the cheap test of that possibility: make the generator a parameter, move the liquidity world underneath every router, and ask whether the ordering survives.

Thirteen worlds, one field at a time

AssignLiquidity now takes a family string. bimodal:<scale> is the fitted shape at the wrong scale. beta:a:b swaps the exponential tails for polynomial ones, and at beta:2:2 the distribution is unimodal and centred — a world where the bimodal hypothesis those priors encode is false. hubdrain:<scale> points the depleted end at the higher-degree node with p = 0.85, the first generator here correlated with topology rather than drawn blind. The legacy strings are golden-tested byte-identical, so every corpus behind every earlier section regenerates unchanged.

Ten hard-tier base scenarios are emitted once, then each family directory holds those same ten files with the single field under test substituted, so paired per-file deltas isolate the generator from topology noise. The advisor flagged a sibling circularity nobody had listed — we author the payment amounts too — so amounts got their own axis with liquidity pinned at the control, and the exp-009 mainnet tier was re-liquified the same way, by a one-line substitution with a parse-and-compare assertion that nothing else moved. Thirteen tiers of ten files against five routers: 650 runs, bootstrap 10k, two-sided sign tests. The sharpest of the three sanity gates is the untouched mainnet control, which had to reproduce the published §01 numbers. It does, to three decimals — 0.694 / 0.762 / 0.790 / 0.791.

The ordering survives every world we could build

lnd is fifth of five on all thirteen tiers. The hand-written seed is third or fourth on all thirteen. An evolved router is first on all thirteen. hb1 − lnd carries a bootstrap confidence interval excluding zero on 12 of 13 tiers and mx_c3 − lnd on 10 of 13. Moving the liquidity family, the amount family and the mainnet balances did not once bring the production stack near the champions.

The margins do shrink as the generator flattens away from the fitted world — hb1's lead over lnd falls from +0.298 on bimodal:0.01 to +0.210 on uniform — and read on its own that shrinkage looks exactly like the overfitting signature the experiment was hunting. The control that kills that reading is the seed.

The seed's margin decays with the same shape and by a similar fraction as the champions', and the seed predates every constant under suspicion. The common cause is visible in lnd's own column of the table above: it climbs from 0.143 to 0.369 as liquidity flattens, so everyone compresses toward a ceiling on the easy worlds. If the champions' compression came from fitted priors, the unfitted seed would hold its margin. It does not. The compression is regime difficulty, not memorised constants.

atomic1 is a flat-liquidity specialist, and the ladder proves it

The one genuine reordering tracks the generator exactly. atomic1's rank across the liquidity ladder runs 4 → 4 → 3 → 1 → 1 → 1 — monotone in rank, its margin over lnd rising from +0.123 to a peak of +0.283 at beta:0.3:0.3 and holding near it on the flattest worlds — and it takes first place on three of the four mainnet families. On beta:2:2 that is unambiguous quality rather than abandonment: the highest success of any router, 0.722, at the fewest attempts, 3.6. The mirror image is equally real. On bimodal:0.01 it is worse on both axes at once — 0.36 success against hb1's 0.55 — which is the abandonment signature exp-013 taught us to read.

So the three evolved routers now have legible regimes: hb1 owns sharply bimodal liquidity, atomic1 owns flat liquidity, and mx_c3 sits between them without owning either. Which is a problem for a title.

The amount axis was never a threat

Holding liquidity at the control and moving only the amount distribution barely touches the champions. hb1's lead over lnd is +0.210 on lognormal amounts — 10 of 10 files, p = .002, the strongest single result in the sweep — and +0.165 on round-value clustering. The sibling circularity is real in principle and empty in practice: the champions' edge does not depend on how we draw the amounts.

The one thing we never varied

The simulator tells a sender exactly which hop failed, at what amount, with which BOLT error, and it tells it immediately. Mainnet does not. A BOLT4 onion error can come back unreadable — the sender learns only that the payment died, not where — a buggy or adversarial hop can blame the wrong place, and every result arrives after a delay during which the network moves. The 8.6× attempt reduction was flagged an upper bound the day the advisor read it, and §07 named degraded attribution the decisive pre-upstream test. This is that measurement.

One delivery point, three degradations

The instrument is an attribution section on the scenario file, and it acts at the single ReportAttempt delivery point that both consumer paths share, so lnd and every candidate face the identical corrupted stream. unknown_prob strips the source and the code; on the lnd path that becomes a nil failure message, exactly what the switch hands mission control on ErrUnreadableFailureMessage, so lnd runs its own real processPaymentOutcomeUnknown rather than a simulation of it. shift_prob blames an adjacent hop with the code intact — a well-formed, plausible, wrong answer. delay_slices holds every result back through slices of background-traffic time. Three uniforms are drawn per attempt whatever the outcome, so the degradation sequence is identical across routers, and with the section absent the binary is proven byte-identical to the pre-change one.

The ladder: the sealed hard tier at six levels — control, unknown 0.1 and 0.3, shift 0.1 and 0.3, and a realistic mix of unknown 0.2 plus shift 0.1 — the mainnet tier at control and mix, and the drift tier isolating delay. 520 paired runs over five routers, with every rebuilt binary gated on reproducing the exp-020 undegraded scores to three decimals; the control column below is that gate, and for the four routers §03 lists it is that page's hard-test column exactly.

1 · The ordering survives the realistic channel

At the realistic mix, and on degraded mainnet, every champion still beats lnd — and on the hard tier the margin widens under unreadable errors rather than narrowing. Nothing resembling the feared “the champions are calibrated to a clean channel and fall over without it” appears anywhere on the ladder. The single level that erases the margin is shift = 0.3, and it gets there by helping lnd, not by hurting anyone.

The reason the champions barely move is one line of policy they all share without ever having been asked for it: none of them writes a liquidity bound from an unattributed failure. The seed ignores it outright, hb1 and mx_c3 apply only a soft session penalty with no interval update, atomic1 marks the route suspect. By evolution or by accident, they treat no-information as no-information — which is exactly the property that matters when a third of the channel goes dark.

2 · lnd's unknown-failure handling is a give-up spiral

processPaymentOutcomeUnknown penalizes every pair on the failed route, in both directions. On the hard tier a 10% unreadable-error rate turns that into give-ups climbing 0.31 → 0.71, attempts collapsing 45.5 → 6.3, and success falling 0.49 → 0.29. At 30%, four files of ten pin to exactly zero: lnd blacklists routes until path finding returns no path at all, and quits. The same signature shows on mainnet at the realistic mix — success 0.790 → 0.730, give-ups doubling, attempts 19.8 → 2.8. No other router shows anything like it.

3 · Being lied to helps lnd, and we do not know why

shift = 0.3 is the best hard-tier configuration lnd has posted in this project's history: +0.122, CI [+0.067, +0.182], ten files of ten, p = .002, with success genuinely rising rather than the attempt-cap term doing the work (that part is only +0.038). Being misinformed a third of the time beats being told the truth.

The candidate mechanism is that on short small-world routes “one hop off” is often the same bottleneck seen from the other side, so a coarser wrong penalty pushes lnd out of a bad region faster than the precise correct one does. That story is refuted: the shift-isolated mainnet arm ran the same night (exp-019b) and the effect vanished — both CIs straddle zero, the sign flips between levels, and the decomposition shows mainnet's small positive is the give-up spiral's attempt term with success falling on 8 of 8 files. Worse for the story, its premise was inverted: mainnet routes are three times shorter than hard-tier routes (first-attempt mean 1.9 hops vs 5.4 — the hub source reaches most targets in one hop), so short-route geometry predicts full strength exactly where the data shows none. The anomaly is real on the hard tier, does not travel to a different graph, and has no surviving mechanism. After §10's three wrong guesses, the anomaly ships labelled as an anomaly.

4 · Delay is free; misattribution is what binds

Holding every result back four attempt-slices on a live drifting network moves nobody: deltas from −0.002 to +0.026, every confidence interval straddling zero, with the counters confirming that 100% of results were in fact delayed. All of the combined level's damage is its misattribution component. That extends the pattern from §08 and exp-015 — evidence staleness keeps failing to matter in this environment — to the delivery channel itself.

5 · The ratio is retired; what replaces it is stronger

Under any unreadable-error rate the attempt ratio inverts: at the realistic mix lnd spends 3.0 attempts per payment against the champions' 16.3. That is not lnd getting efficient, it is lnd giving up on the hard payments, which makes attempt ratios on a degraded channel meaningless in both directions. The 8.6× was a perfect-channel artifact and this page no longer leads with it.

The replacement claim is the better one. On degraded mainnet the champions hold success at exactly their undegraded values — 0.810 → 0.810, 0.800 → 0.800 — for an extra 0.2 to 0.45 attempts, while lnd buys its attempt drop with six points of success and twice the give-ups. Realistic degradation converts the champions' edge from an efficiency edge into a robustness edge. The efficiency was fair-weather; the robustness is structural.

The confound, which was registered before the answer

§05 called a band 0.014 wide a paradigm ceiling on the strength of three lineages converging inside it. All three were bred by the same optimizer. Three roads to one destination is evidence about the map only if the roads are independent, and engine="gepa" is the one thing every run in this program held fixed, so the convergence said as much about one optimizer's attractor as about the problem. The GEPA team's own multi-engine results — no engine dominant, each winning about a third of the problems — made the alternative live rather than merely conceivable, which is why it has sat in §00 as a correction to our own record.

The adjudication is the cheapest version of the test. Three engines get the same seed — the in-tree candidate slot — the same corpus, the ground exp-011 was fought on, and the same 150-evaluation budget, with a verdict rendered per arm. The two claude-driven arms ran under the sterile config home with the durable JSON fix, and the containment held: neither crashed, leaked, nor wandered off task. They simply produced nothing.

Why nothing came back is the finding

meta_harness benchmarks each proposed candidate against the full example set, sixty-eight evaluations at a time, so 150 bought it exactly one iteration: its first real proposal scored 0.058 — broken — its second ran out of budget in the middle of its own benchmark, and the “best” it reported is the seed it started from. autoresearch consumed its whole allowance in thirteen minutes without once beating that seed. gepa spent the same 150 evaluations across thirteen iterations, because a minibatch is a handful of examples rather than all of them.

The budget-unit asymmetry each engine records — cache-miss accounting, proposal caps, what counts as one evaluation at all — is not a footnote at this scale. It is the whole outcome. gepa's moat here is eval efficiency, not proposal quality. Nothing in this run says the claude arms propose worse routers; it says they never got far enough to find out, and that at any budget somebody would actually pay for, the distinction does not matter.

omni1: challenger failure number six

gepa's arm did produce a router, and internally it looked real — held-out test 0.556 against the seed's 0.508. The inflated-metric caveat held one more time. Rebuilt and scored against the incumbents on the adjudication tier set, omni1 beats no champion anywhere. Its only delta whose confidence interval clears zero is +0.011 over hb1 on split test — the tier where hb1 is the known weak twin (§11) — and the sign test on it reads p = 0.219, which lands it on exactly atomic1's second-place shelf. Against mx_c3 it is negative on all six tiers, twice with intervals excluding zero.

It is not an exp-010-style collapse, though, and that is worth saying plainly: omni1 clears lnd on five of the six tiers, by +0.271 on the hard tier at ten files of ten, and it posts the highest success of any router on atomic test. What it does instead is the exact inverse of the give-up attractor. omni1 is the most attempt-expensive evolved router this project has measured, on every tier — 85.8 per payment on atomic test against mx_c3's 12.9 — buying champion-or-better success with attempts the composite then taxes back off it.

The source audit says the cause is an absence rather than a strategy. omni1 carries none of the champions' guardrails: no attempt limit, no hop cap, no search budget. Nothing in it ever decides to stop. And since the objective caps the attempt penalty at fifteen extra attempts, its 0.427 on atomic test flatters it — past the cap, eighty-five attempts cost no more than thirty. Champions of record are unchanged: hb1 and mx_c3, now six challengers deep — eight as of §15 and §16, nine as of §18, and the eighth reaches omni1's no-guardrail shape by an entirely different road.

Two mechanisms for the ledger, out of a router that failed

Dual belief ledgers. omni1 keeps two books per directed channel and blends them at different strengths: one learns amounts inflated by its own in-flight shard reservations — blocked right now by my own MPP contention — and one learns raw attempt amounts, the channel's standing balance. No champion separates those two kinds of failure, and in the atomic arena (§07) they are genuinely different facts about the world.

Contradiction-triggered confidence decay. Instead of a clock, evidence that contradicts a bound clears the bound and halves the confidence behind it. Evidence-keyed forgetting sidesteps the decay question exp-008 and exp-015 have been arguing over rather than answering it, and by construction it costs nothing on the static tiers. One incidental for §00's fitted-constants worry, too: omni1's low-mode prior constant is 0.025 and not the generator's 0.05, which is one more data point for §11's finding that the fitted constants are not where the performance lives.

Both halves are real lnd code

Neither mechanism lives in adapter glue. They are flag-gated changes to payment_session.go, result_interpretation.go and missioncontrol.go, and the simulator's --router=lnd arm traverses the genuine paymentSession.RequestRoute and mission-control interpretation paths on its way through them. With both flags off the binary is proven byte-identical to stock, and the stock arm reproduces the cached §12 numbers bit-for-bit before anything is counted.

Part B · soft_unknown, the fix that lands

§12 found that lnd's response to an unreadable failure — processPaymentOutcomeUnknown penalizing every pair of the route in both directions — turns a 10% unreadable-error rate into a give-up spiral. The patch replaces the nuke with a minimal-progress penalty: fail exactly one pair, the lowest-probability hop under the current estimator, at the attempt amount. Something is always learned, so the loop always makes progress, and the route set is never exhausted at a stroke.

Success rises on every non-tied file, sign tests p = .016 to .031, and give-ups fall on every non-tied file at every hard and drift level. The patched arm processes 5 to 12× more unattributed failures than stock — because it no longer quits before they arrive — and improves anyway.

The invariance claim from the smoke survives contact with the real corpora: patched lnd's degraded trajectory is statistically indistinguishable from its own clean control on hard and drift. At the realistic mix it is in fact above its own clean control, +0.058 [+0.017, +0.094]. That mix contains shift 0.1, so this may be §12's third finding — being lied to helps lnd — resurfacing on the patched stack. No mechanism is claimed for it here either.

The patch is also a partial answer to this project's own scoreboard. It takes back roughly half of the champions' degraded-tier margin, and it erases atomic1's outright at unknown .3 and on the drift mix.

Part A · adaptive_split, three designs and one arithmetic

The other half was meant to teach lnd's payment loop the champions' inverted question: not which route carries this amount but what is the largest amount that still has hope? The vehicle was capped pathfinding probes inside RequestRoute, which can ask the estimator about an amount without putting an HTLC on the wire. Three designs went through the smoke gate, and every one of them was killed by its own trace before a sweep spent real compute.

1 · Supremum search. After a wire failure at A, the estimator permits essentially everything below A, so the largest routable amount it can find is A−ε — which fails on the wire, yielding a new bound and a new near-supremum. That is a linear descent paying one real attempt per step, and it scored −0.03.

2 · Geometric backoff below the frontier. Back off 0.75× from the located frontier instead. The realised ratios come out at 0.703, which is blind descent — a slower re-derivation of the 0.5 lnd already uses. The frontier the probes locate is just the failing amount minus the search's own resolution; it carries no information the bound did not already carry.

3 · Expected-value ladder. Score mx_c3's shard fractions by amount × route probability — the probability lnd's pathfinder already computes and RequestRoute throws away. Under apriori's flat belief the argmax degenerates to the top rung, which is revision 1 again, this time as a property of the value model rather than of the search. Under the bimodal estimator the ladder does jump straight to the believed rung — and lands in the same retry loop that pins stock-bimodal at the attempt cap (§09).

One interim number survived a revision cycle and should not have. On the mainnet smoke the bimodal ladder posted 0.733, which looked like the estimator × control-flow marriage finally working. It was entirely abandonment: the ladder was quitting below its bottom rung. Closing that channel — falling back to stock descent instead of giving up — made A″+bimodal reproduce stock-bimodal's aggregates exactly, and the claim was retracted the same evening by its own author.

The paired sweep on the clean tiers gives the final word, and it is a shrug: hard +0.034 [−0.002, +0.074], mainnet −0.010 [−0.029, +0.000], sign tests nowhere near significance, a heterogeneous few-file signal pointing both ways. Not a loss worth citing. A genuine null.

Where this leaves the upstream conversation

Part B is PR-ready. Roughly ninety lines in result_interpretation.go and missioncontrol.go, against a measured pathology, with a unanimous success and give-up direction, provably inert on a clean channel, and a cost line stated in the open. The known limitation ships with it: the minimum-probability hop choice degenerates under the bimodal estimator, because no capacity is available inside result interpretation, so the patch is apriori-only until capacity is threaded through. Part A stays in the tree as flag-gated instrumentation with its null attached, and the three-revision arc above is its documentation.

The starting-line story is dead, and the shelf replaces it

Given room, meta_harness does what an optimizer is supposed to do. Eight iterations, five of them finding a new best, a real 422-line candidate at the end — log_bimodal_cost, exploit-grep clean — and the first improvement over the seed that any claude-proposer engine has produced in this program. exp-018's reading that the claude arms are containable but empty-handed was a budget artifact, and it is now retired.

What replaces it is worse for the alternative, not better. The shelf the arm converges to sits 0.043 of held-out test below gepa's own result at one tenth the eval budget, and gepa's result is itself well below the champions. Whatever the ~0.64 band is, it is not “the only optimizer we tried,” and it is not “nobody gave the others enough evaluations.”

log_bimodal_cost: challenger failure number seven

The winner is the first challenger this program has filed from a claude proposer, and it gets no tier sweep. At 0.5136 held-out test against a seed of 0.5082, with both champions far above, there is no hypothesis a sweep would test. The candidate names alone read like a search circling one idea: directional_belief, capacity_penalty, log_bimodal_cost, failure_code_filter, widest_path_routing. Every one of them is a way to shape a cost function, and none of them is a way to remember an interval.

The corpus that lies, and the gate before it

corpus-deg is the sealed corpus-mix train and validation splits with §12's realistic mix stamped on every file — unknown_prob 0.2, shift_prob 0.1 — and the test split left clean, so the held-out line reads transfer back to a truthful channel. The background prompt gained a section stating the channel facts and posing the open question outright: nobody has evolved machinery that actively exploits a lying channel. 400 evaluations, pure gepa, codex gpt-5.6-sol at high effort, 36 iterations, ten candidates in the pool, no reflection hijacks. The launch gate held first: the in-tree seed reproduced exp-011's iteration-zero validation score to full float precision on the clean split before anything counted.

Two numbers came out, and they told two stories. On the degraded world it was bred for, the winner gains +0.044 over the seed, 0.3906 to 0.4343, which is what evolution buys on clean corpora at this budget. On the clean held-out test it lands 0.009 below its own seed, 0.5082 to 0.4988. Robustness machinery is not free when the channel stops lying, and which of those dominates on the sealed tiers is what the 648-run sweep was pre-registered to decide.

What it evolved, which is the reason the run existed

deg1 is the first candidate in the program to build attribution-confidence machinery instead of ignoring what it cannot read, and it built all three pieces without being shown an implementation of any of them.

1 · Quarantined suspect evidence. Per-directed-channel suspectAmt and suspectWeight fields hold observations whose attribution the router does not trust, kept apart from the hard lowerOK and upperFail bounds. A suspect entry is cleared when later evidence contradicts it, rather than poisoning the interval it would otherwise have written.

2 · Payment-local penalties for unreadable failures. On an unknown failure it penalizes every edge the attempt traversed within that payment — 0.16 an edge, softening to 0.11 on long routes — and writes nothing at all to shared beliefs. That is convergent with the champions' session penalties and with soft_unknown's design logic (§14), evolved independently, under exactly the pressure that produced the lnd pathology.

3 · An escalation threshold. After four unknown failures inside one payment it changes policy rather than looping — the guardrail class omni1 conspicuously lacked, and a hint of the shape a bounded version of this router would take.

No displacement. deg1 beats a champion with an interval clearing zero on zero tiers, in either channel condition. Its best cell is atomic test degraded, +0.043 over hb1 and +0.041 over mx_c3, and both straddle zero. Going the other way it loses to mx_c3 with intervals excluding zero on four tiers, unanimously on split (0 of 8, p = .008) and on mainnet (0 of 10, p = .002, −0.11 against all three incumbents). That mainnet cell is a first: no evolved router in this program had previously landed below production lnd on lnd's home tier. Read the pair, though, and the sting is precise rather than general — deg1's mainnet success is 0.800 against lnd's 0.790. It loses the composite on the attempt bill alone, 25.9 attempts a payment against 19.8. It also earns no specialist filing beside atomic1's flat-liquidity niche, because atomic1's niche wins were interval-solid and deg1's degraded edges are not.

What it was bred for, it achieved

The breeding worked on its own terms, and the flatness is the cleanest result in the run. deg1 is the most degradation-robust router ever measured here, and the champion gap narrows under the lying channel exactly as the breeding predicted, with intervals excluding zero on the hard tier: +0.051 against hb1 (9 of 10, p = .021) and +0.056 against mx_c3 (10 of 10, p = .002).

And then the mechanism, which is the finding

The flatness is bought by never stopping. deg1 runs 26 to 92 attempts a payment on every tier, pinned past the objective's fifteen-extra-attempt cap everywhere, and it fails almost never by giving up. It is the first candidate to break the give-up identity that §11 established: its give-up rate runs 0.000 to 0.090 while its failure rate runs 0.083 to 0.397, so it is not abandoning payments at all. The harness's 200-attempt ceiling in sim_run.go abandons for it.

Re-scoring the identical raw runs at higher attempt caps shows the subsidy plainly, and it is the exhibit that decides the section.

deg1's one directional tier lead inverts at cap 30 and lands worst in field uncapped. The champions do not move: hb1 reads 0.586, 0.585, 0.585, 0.585 on the hard tier across the same four caps. The cap is not measuring the same thing for both kinds of router, and on this candidate it was paying for the headline.

Two things worth keeping out of a router that lost

The suspect-bound machinery is real, novel and goes on the idea ledger. It is the first evolved answer to the attribution question, and its degradation-flatness is genuine rather than a scoring artifact — the flatness holds on success, not just on the composite. The obvious follow-up is to seed from mx_c3 against the degraded corpus and ask whether the machinery composes with a plan-time architecture instead of replacing it.

The attempt cap is now a measured objective weakness rather than a suspicion. It silently subsidized this candidate the same way it hid soft_unknown's cost in §14. The economic-realism spec already carries a rule that a fee term must stay below the abandonment price; this is its attempt-side sibling, and it generalizes: a capped cost term creates a free direction past the cap. Any future objective revision should treat the two symmetrically. Two things have happened to this finding since: §17 re-scored the archived runs on time instead of attempts and found the axis swap flips no sign anywhere, and §18 made the cap re-scoring a mandatory gate on every margin a new candidate claims.

Five mechanisms, five flags, one day

Stage A gives every channel the min and max HTLC it announces, with an empirical family fitted to all 62,798 directed policies of the mainnet snapshot. Stage B gives nodes inbound fees, including the 4,783 real policies the describegraph loader used to parse and throw away. Stage C gives a payment a fee budget, tells its sender what that budget is, and refuses a route that would overrun it instead of sending it. Stage D lets the sender run several of its own payments at once, racing itself for its own outbound liquidity, on a deterministic virtual-time event loop that reduces to the sequential batch exactly. Stage E stops pricing an attempt as a flat tick: it costs an overhead plus a round trip to the hop that resolved it, so a failure at hop eight is eight times the wait of a failure at the sender's own first hop.

The objective never changed. That was the point of the design: the pressure went into the environment rather than into the weight, so that nothing on this page moves for scoring reasons. The gates ran first and they ran the strong way — every clean sealed tier reproduced §16's table on 24 of 24 cells to the bit, and every knobbed tier had to show its engagement counters nonzero before its results were allowed to count. 1,920 runs, zero errors.

The rung where lnd takes the tier back

Fee budgets are the mechanism, and the mainnet ladder is where to read them. On the clean tier the champions lead lnd by +0.097. Switch on a budget and that lead goes negative at every rung as a point estimate, and at 25 ppm lnd finishes ahead of both champions — the production stack taking a tier back, which happens nowhere else on this page. The reason is not subtle: lnd prunes on the budget inside its own pathfinding, so it never dispatches a route it cannot afford, while the interval routers — which score a path in probability and have no idea what the sender will tolerate — walk into refusal after refusal, each one costing an attempt and teaching them nothing.

Stated with its caveat, because the caveat is real. The narrowing clears the pre-registered bar unanimously. The inversion does not: those negative leads have intervals excluding zero but sign tests of .07 to .29, so what is established is that the gap closes, not that it reverses.

atomic1 prices in money; the champions price in nats

One router does not follow the others down the ladder. atomic1 holds +0.061 over lnd at 400 ppm with the interval excluding zero, and ties at 25 ppm where both champions are well behind. It deserved a source audit before anything was concluded from it, and the audit found the answer in the units.

atomic1's path score is denominated in millisatoshis: it buys probability at a flat 420,000 msat per nat of log-probability. Both champions do the exact opposite — they score in nats and convert fees into probability at a rate proportional to 1/amount, a penalty of k·fee/amount with k of 15 for hb1 and 5 for mx_c3. Their willingness to pay for one nat of reliability is therefore about 7% and 20% of the payment, whatever the payment is, which is a term that never binds. At the mainnet median amount that reads 420 ppm against 66,667 and 200,000: atomic1 is 159× more fee-sensitive than hb1 and 476× more than mx_c3. Its attempted routes cost 130 ppm where the champions' cost 224, and at 400 ppm it is refused 27 times a file against hb1's 152.

The denomination has a second consequence aimed straight at a ppm budget. Because atomic1's exchange rate is an absolute amount, its implicit ceiling in ppm terms tightens as the payment grows — 4,200 ppm on a small payment, 210 ppm on a large one — so the payments where a ppm budget bites hardest in absolute money automatically get the tighter ceiling. The amount-relative routers are scale-free and structurally cannot do this. The usual caveat applies and is the reason for quoting the constant: 420,000 was fitted in an arena whose amounts run 1e8 to 2e9 msat. The mechanism is portable; the number is not.

What the audit did not find is a budget reader. No incumbent, atomic1 included, ever looks at the fee limit it is handed, and all three respond to a refusal identically by blocking the first-hop edge for the rest of the payment. The whole difference is how often a router walks into one. Alongside the pricing, atomic1 is also the contention-immune router: a per-edge reservation ledger rebuilt from its own in-flight count leaves it 2.85 self-contention failures a file at window 4 against hb1's 40.5 and lnd's 88.5, its attempts flat from 6.1 to 7.3 across the window ladder where hb1's triple from 7.1 to 21.6, and its makespan 33.8 seconds against 81.0 and 223.9.

A correction the accounting handed us

Stage C was specified as a housekeeping fix and turned out to be a correction. The arena reported fees only for payments that completed, but a partially settled multi-part payment that later fails has genuinely paid its forwarding nodes. Re-totalled from the per-scenario records, the invisible share is 40.8% on the sealed hard tier, 41.5% on OOD and 41.7% on mainnet: every fee number this program has published is the 59%. Nothing about the orderings moves — the fee term is worth at most 0.1 of objective and it saturates — and every archived run can be re-totalled without re-execution, because each scenario carried its own spent fee all along.

Fifty-nine proposals, one missing type

The first attempt died an instructive death. The background prompt described the inbound-fee semantics without ever naming the Go type, and a code-writing model handed a described-but-unnamed field does the obvious thing: it invents an API. Fifty-three proposals reached for reflect to duck-type their way into an Option wrapper that does not exist — and every one was rejected by the banned-identifier sandbox from §21, which is the cleanest demonstration of that seal the program has had. Six more guessed UnwrapOr on a plain struct and failed to compile. Eight prompt lines fixed it: state the type, show the field reads, name the ban. The lesson generalises to every harness prompt this program will ever write.

The relaunch ran 382 evaluations on the same corpus and seeds and accepted nine candidates. The winner, econ2, is 1,230 lines, exploit-grep clean, and byte-matched against the runner's own final selection.

What evolution built when money was real

econ2 is the first candidate to touch either economic contract surface: it reads spec.FeeLimitMsat and it prices inbound fees, both of which every incumbent — champions included — ignores entirely. And the machinery is planning, not re-weighting. A remaining-budget ledger net of settled shards. Per-shard budget allocation that decrements as shards commit. Fee-cap pruning inside the Dijkstra rather than as a filter after it. A fee-for-reliability exchange rate derived from the budget itself, so the router gets stingier as the budget runs down. And an eight-label Pareto search over score, fee and amount that never evicts the minimum-fee label, so a cheap feasible path stays in the frontier for exactly the case where the budget binds.

Around that sits a collection of things this program has been waiting to see re-derived: the dual belief ledger from §13's idea list, realised as process-global soft beliefs against a payment-local strict upper bound; confidence time-decay, re-invented after both champions dropped it; policy failures deliberately kept out of the liquidity beliefs; and §14's soft_unknown shape for unattributed failures, arrived at independently. One defect, caught by the sweep's own counters and recorded rather than patched: it computes the inbound fee on the incoming amount where the wire charges it on the outgoing amount plus the outbound fee, so it underpays a positive surcharge by a few hundred msat and eats 13 refusals a file on the heavy tier where lnd eats zero.

Specialist, not champion — and the honest half of the headline

The displacement answer is no, and it is not close. econ2 loses the classic sealed set to both champions, four tiers to one against hb1 and four to nothing against mx_c3, and it loses two to three of the four economic control tiers as well. Its worst result is drift: −0.16 against hb1, −0.17 against mx_c3, and −0.13 against the hand-written seed. The cause was pre-registered in the corpus README before the run started — the composition world is low-drift by construction, so econ2 never bred against staleness at all.

The specialist filing is a different matter and it is interval-solid. On the fee-budget family econ2 beats hb1 on 4 of 4 tiers, mx_c3 on 3 of 4 and atomic1 on 3 of 4 with intervals excluding zero, unanimously on mainnet at 100 ppm — 10 of 10 against both champions, p = .002. Its budget discipline is the strong form of the hypothesis: zero refusals on every budgeted tier, matching lnd exactly, where every other evolved router violates constantly.

The cap check is mandatory now, and it splits. §16 made the attempt cap a measured weakness rather than a suspicion, so every margin here was re-scored at 30, 60 and no cap. The fee-budget leads survive uncapped — the 2000 ppm margin is identical at every cap, and both mainnet rungs grow — because econ2 spends 5.4 attempts a payment there, nowhere near saturation. The held-out econ_test headline does not: 56% of its margin over hb1, 68% over mx_c3 and 73% over atomic1 is cap subsidy, at 21.4 attempts a payment against the champions' 7 to 12. No sign flips, and econ2 still wins that tier on raw success and on fees — but the intervals stop excluding zero once attempts are priced in full, and the number is filed with that label attached.

The first live bar, cleared

Every beat-lnd result on this page until now came on a corpus where the hand-written seed already beat lnd, which makes the bar decorative. The economic corpus is the first where lnd outscores the seed, and econ2 clears it: +0.135 on validation with the interval excluding zero and p = .004, and all four fee-budget rungs with intervals excluding zero. The held-out test agrees at +0.048, 16 files of 20, p = .012 — quoted with the qualifier it earns, because at the published attempt cap its interval straddles zero by 0.002, and only clears once the cap is lifted. The sharpest form of it is the join with §17: the champions' clean-mainnet lead goes negative at every fee rung, and econ2 restores an lnd-beating lead in exactly that place, 0.721 against lnd's 0.627 at 400 ppm, best of all six routers.

The port, and the gates before it

A fresh worktree merged the branch into the simulator tree, and a new router_impl=interval knob swaps lnd's stock payment session for newIntervalPaymentSession on the simulator's lnd arm. Mission control is still built and still fed every outcome, exactly as on a real node running the flag. Two lifecycle seams are mirrored rather than approximated: result delivery uses the same source index and message mission control just received (an unreadable failure delivers nothing at all), and a finisher hook stands in for the deferred attempt release.

Two gates ran before any science. The merged binary with the knob off is byte-identical to the merge-base binary on 104 of 104 self-deterministic cells, 50.8 MB of stdout with traces on, and the §17 gate table reproduces on 24 of 24 cells to the bit. Then a six-arm, fourteen-tier, 134-file battery: 804 runs, zero errors, three pre-registered questions.

Three falsified hypotheses, and the bug underneath them

Round 3 added a budget-derived fee price and a suspect-bound quarantine, and split down the middle: the price was the only round-over-round delta in the sweep whose interval excluded zero (hard at 4000 ppm, +0.079, flipping the tier from a straddle against lnd to +0.107), while the quarantine was a null on its own home turf and the degraded-mainnet gap it was built to close moved the wrong way. It also left one regression to explain, a −0.032 on the out-of-distribution tier, and that took three more rounds.

1 · The frontier rule: falsified. Gating the cheapest-label keep on a budget changed nothing measurable on any of the fourteen tiers. The gate was inert. The same round established something more useful: the interval arm is not run-to-run reproducible on any binary, which forced a replicate protocol that made the next two rounds cheap.

2 · IEEE-754: half right. Round 3 had rewritten 5·fee/max(amt,1) through a reciprocal price, equal in exact arithmetic and a different double on about a quarter of realistic pairs, and the frontier compares scores exactly. Restoring the verbatim expression recovered the single-shard tiers precisely (split, mainnet and atomic to ±0.0005) and left every tier that splits untouched. The float story was real, and it could not explain the survivors.

3 · The bug: a budget's remainder is not its existence. intervalBudgeted tested whether the fee limit was the unbudgeted sentinel, but lnd's lifecycle hands the session what the limit has left, recomputed on every route request. An unbudgeted payment carries the sentinel only on its first request; from shard two onward it carries the sentinel minus fees already paid, is misclassified as budgeted, and gets a clamped absolute price for a budget that does not exist. Single-shard payments never reach a second request, which is exactly the restored-versus-stuck split round 5 had measured. The fix latches budgetedness once at session construction, from the payment's own limit, and lets the live remainder go on setting the price. Round 6 adjudicated it: ten of eleven unbudgeted tiers return to their round-2 values (the out-of-distribution tier lands at 0.5703 against a 0.5702 prediction), all three budgeted rungs are bit-identical to round 3, and hard at 4000 ppm holds its 0.410.

The production default, which is the configuration upstream will ask about

Tracing the latch seam surfaced something the whole fee story had been missing. Production lnd essentially never sends the unbudgeted sentinel: the RPC layer falls back to a default routing fee limit of 100% up to 1,000 satoshis and 5% above it, so a real node takes the budgeted branch on every payment it makes. Zero of the 411 payments in the classic corpus sit under that cut-off, which makes a uniform 50,000 ppm an exact reproduction of production rather than an approximation of it.

Under exactly that budget the result holds. Margins over stock lnd stay interval-solid on all six classic tiers (hard +0.261, mainnet +0.093), the absolute price ceiling the branch applies costs at most 0.0095 anywhere and gains on drift, and no arm refuses a single route: not lnd, not the integrated branch, and not mx_c3, which refused hundreds a file on the tight rungs of §17. That reframes this program's own fee findings. The budget-discipline results in §17 and §18 are statements about tight budgets, not about the node in front of you.

Two open edges, both localized

The champions lose exactly zero success on degraded mainnet where the integrated branch loses 0.050, and the round-3 quarantine built to close that gap widened it instead. Whatever buys the champions their zero there, it is measurably not suspect-bound discounting, and the question goes back on the board. Filed alongside it is an interaction nobody predicted: the degraded hard mix sits 0.034 below round 2 at 32 replicates (z = −11.1) while unknown-only, shift-only and unknown-at-0.3 all sit at or above it, so the two attribution mechanisms together cost roughly five times the sum of their separate parts. The working hypothesis, measured interaction and unproven mechanism: the quarantine handles failures that cannot name a channel, and loses ground when failures name the wrong one.

A healthy run and a real candidate

Nothing about the run was broken. All 400 evaluations landed, 35 proposals were scored, ten were accepted into the pool, and no reflection was hijacked. The best-validation candidate is real machinery too: it keeps econ2's budget ledger and inbound pricing and adds an edge-penalty and blocked-set attribution layer with suspect handling on top. Then it loses to its own seed on held-out, and the decomposition is the pre-registered pattern rather than noise. The runner's printed numbers were reproduced to four digits by an independent overlay rebuild and a 20-file re-run before any of this was written down.

The rule, and the selection layer that hid it

econ2 sits at the attempt-heavy end of this world, 22.6 attempts a payment, which leaves exactly one cheap direction for a continuation to walk in: shed attempts by abandoning payments. That is what exp-013 found when it continued atomic1, a router already at the attempt frontier, and it is what happened here with the lineage and the environment both swapped out. The rule this promotes is worth stating plainly: continue a seed that sits at the attempt frontier and the optimizer becomes an abandonment machine, because the composite objective hides abandonment inside the same number as efficiency.

The selection layer failed honestly beside it. gepa's best-validation pick scored 0.2833 on minibatch validation and then undershot its own seed on held-out by 0.030, which is minibatch validation selecting a validation-shaped candidate. Every champion on this page was decided by separate held-out runs for exactly this reason, and this is the cleanest demonstration of the reason the program has.

What makes this balance sheet foreign

Our generator draws hidden balances as a fixed fraction of capacity and puts roughly 63% of channels in the sub-5% or over-95% tails, which is a sharp bimodal world. The model graph is a soft U instead: 32.7% in those tails, and a fat middle ours never draws. A loader flag reads the graph's own balance field, and the tier otherwise mirrors the sealed §01 shape as closely as the key remapping allows. The same hub carries through the graph's own key mapping, still degree 2,013 and still rank one, and targets are drawn to match the sealed tier's empirical target-degree distribution rather than uniformly, because a uniform draw would have put 58% of payments on degree-one leaves and walked straight back into the reachability trap of §08.

The replicate protocol from §19 carried over, and earned its place again: a three-sample determinism screen called the tier clean and a full pass found 53 of 200 cells nondeterministic, every one of them an lnd or an integration-branch cell. The worst objective range across replicates is 0.0012, two orders below the smallest margin on the table below, and the five evolved candidates are exactly deterministic.

A specialist filing predicts a result on data it never saw

atomic1 on top is the part of this that could not have been arranged. §11 filed it as the flat-liquidity specialist on the strength of a monotone ladder, rank four to rank one as the liquidity family flattened, and filed it before this graph existed in the project. The model graph's soft U is the flattest realistic family we have ever scored, and the specialist takes the tier. A story that predicts an ordering on somebody else's data is a different kind of evidence from a story that explains one after the fact.

The de-circularization answer, in one paired swap

The decisive comparison is not the leaderboard, it is the swap. Hold the files, the topology, the vantage and the payments fixed, change only which process drew the balances, and ask what each arm gains. If the champions' mainnet numbers were an artifact of priors fit to sim_liquidity.go, this is exactly where it shows: the fitted arms should lose ground when the family moves and the never-fitted ones should not care. The direction runs the other way, and nothing in it is significant.

The spread between arms is smaller than any single arm's interval, so the honest reading is that the liquidity family is worth nothing to anybody here, not that the seed secretly prefers foreign balances. A source-rebalance control confirms the loader's unbalanced-source choice carries none of it. What stays authored after this is the topology-shaped part, which every arm shares equally, and the residual escape is the one that was always going to be last: offline replay on a real node's own history.

The release candidate on somebody else's data

The integration branch of §19 was measured here as a seventh arm, and it tracks the champions to the third decimal: −0.0009 against mx_c3, −0.0008 against hb1, −0.0060 against atomic1, every interval straddling zero. Under the production-default fee limit, which §19 established is what a real node always sends, it gains 0.0038 while paying 267 fewer parts per million, and no arm refuses a single route. That reproduces the production-default finding on external data, and it is the version of the claim an upstream reviewer will care about: champion-grade on a world neither the branch nor the champions were ever fit to.

A signal in the graph that nobody reads

The model graph is built with a fee-to-depletion correlation inside it, and the correlation is live: Spearman −0.149 between a directed end's fee rate and its balance fraction across 74,406 ends. Whether any router exploited it is not cleanly measurable from aggregates, so it is reported as not measurable rather than forced, but the well-posed substitute is negative. If the signal were being read, the fee-pricing arms should gain more on the foreign balances than on ours, and they do not: econ2 sits mid-pack in the swap table, bracketed by the hand seed and by stock lnd. A router that treats the fee schedule as a liquidity prior is unclaimed ground, and this is the tier where the signal is guaranteed to be there.

The mechanism, in three rules that are each individually correct

The ablation is decisive and it is also, at first, the wrong lesson. Disable the quarantine and change nothing else, and the mixed tier recovers +0.0355 while every other tier stays where it was. The entire loss is the quarantine. But the quarantine's own logic is not what is broken. It is disarmed by evidence the rest of the stack manufactures, in three steps:

1 · A named failure exonerates everything upstream of it. When a failure names a hop, every hop before that index demonstrably forwarded the amount, so the belief system writes each of them a hard lower bound. That is sound, and it is sound only for as long as the report is honest.

2 · A shifted report names the wrong hop. Blame shifted downstream places the true culprit before the reported index, which means the guilty channel collects a lower bound certifying it can carry the very amount it just refused.

3 · That false certificate disarms the quarantine. All three suppression rules read the lower bound, so the guilty channel is filtered off the suspect list, never recorded as a suspect again, and has its contradictions cleared. Removing the culprit from the suspect list does not merely lose one conviction: the quarantine spreads a fixed 1/√n weight over the suspects that remain, so striking off the guilty party concentrates the whole suspicion on the innocent survivors.

Each degradation alone leaves the loop open. Unreadable errors never shift blame, so no false bound is ever written and 0.0% of promoted bounds land on innocent channels. Shifted blame never produces an unnameable failure, so the quarantine barely runs at all and records zero suspects. Run both and the loop closes: 9.6% of the mixed tier's promoted hard bounds land on channels that never failed, there are more promotions than on the harsher unreadable-at-0.3 tier despite fewer unreadable failures, and the suppression rules fire 39% to 73% more often. The counters read the simulator's record of which channel actually failed before degradation, so this is measured rather than inferred, and it is what promotes a correlation into a mechanism.

Four fixes, and the one that is principled as well as best

V3 adds one field. A ProvenOK level written only when a payment settles through the channel, and the quarantine's three suppression rules read that instead of the lower bound. The lower bound keeps its entire pathfinding role and loses one job it should never have had: it stops counting as proof of innocence. A hop before a named index is proven only if the naming is honest, which is precisely the assumption misattribution breaks. A settlement is not an inference from a report, it is the payment arriving. V3 takes the mixed tier above the pre-quarantine reference, leaves the clean tier identical to seven decimals, and gives back only an insignificant sliver of the unreadable-only gains. No variant recovers the mixed tier and keeps the full unreadable-at-0.3 gain, so this is the best point on a real trade rather than a free lunch.

It also settles a question §19 left open. The quarantine had been positive on some degraded tiers and negative on this one, which is the shape of a mechanism that should probably be dropped. With V3 in place it is positive or neutral everywhere, so the quarantine keeps, and it stays severable behind its own config knob for anyone who disagrees.

The committed version, measured rather than assumed

Everything above was measured on throwaway builds. The shipped implementation is not identical to them: it clamps the proven level to capacity, zeroes it when a belief is restored from disk, since a settlement seen before a restart is evidence about a network that has had the restart to move on, and guards two of its three read sites on the field being set rather than on a zero comparing false. So it was re-benched against the throwaway rather than assumed equal to it, and it is equal: every paired delta on all five tiers straddles zero with a replicate z of 0.2 or less.

The counters tell the same story in production form, and they tell it better than the scores do. On the mixed tier the innocent-conviction rate falls from 9.6% to 8.4%, which lands on the shifted-only floor of 8.3%. That floor is the correct target and zero is not: bounds written straight from a named failure are misattributed whenever the naming is, and the fix does not touch that path. The quarantine was only ever responsible for the excess above the floor, 1.3 points of it, and 0.1 remains. Suspects struck off the list by false evidence fall from 1,100 to 526 and suspicions cleared fall from 133 to 50. The cost side is visible too, and it is the same event: promotions on the unreadable-0.3 tier rise from 11 to 55, because suspicion that honest probes used to clear now survives to conviction, which is exactly the small give-back the scores show.

The ladder, final form

Read down this table and the whole evolution track is in it. Each world adds one kind of pressure to the one above, at an identical optimizer, budget and seed, and the return on reflective search falls monotonically to nothing.

Read this beside §15, where a different optimizer at ten times the budget converged below gepa's result, and the conclusion stops being a suspicion. The compose world is closed to the seed-plus-insights recipe at any seed and any practical budget. A mixed environment prices complexity faster than sixty reflective proposals can pay for it, and no amount of the same search buys the difference.

What the boundary says about everything above it

The boundary is informative rather than disappointing, and the informative part is a pattern that took thirty-one experiments to become visible. Every mechanism this frontier owns was bred in a world that applied exactly one pressure: the liquidity intervals of §04 in the clean world, the budget arithmetic of §18 in the economic one, the attribution confidence of §16 under the lying channel. No run in this program has ever built machinery under two pressures at once. What carries all three families today is not an evolved router at all. It is the integration branch of §19, hand-assembled from what the search found and validated three separate ways since: fourteen tiers inside lnd's own lifecycle, a foreign balance sheet (§21), and a mechanism found and fixed under degraded attribution (§22).

The sandbox had a hole, and the audit found it first

An adversarial review of the simulator turned up one critical finding: the gossip view's GraphSession delegated straight to the concrete simulator graph, handing the callback a *SimGraph. A candidate could type-assert it back and read every hidden balance — or call AssignLiquidity and rewrite ground truth. A perfect score, using no banned identifier. The reviewer demonstrated the escape end to end.

It was sealed the same day: the session now passes only the sealed view, with a regression test asserting neither the view nor its graph can be asserted back. Then every in-flight candidate was audited for the escape path. Zero hits. The optimizer had not found the hole, so no result was corrupted — but the margin was days, not months, and the lesson is that a reward-hackable evaluator is the default state of an evaluator until someone attacks it.

Code evolution hits a complexity wall around 800 lines

Past roughly 800 lines, LLM edits to a candidate frequently stop compiling. The breakthrough run's iterations after its first accept largely failed to build, and the follow-up run's later frontier members grew from 1,306 to 1,525 lines without improving generalization. Growth and editability trade off against each other, and nothing in the loop currently pushes back — a simplification instruction in the reflection prompt, or a size term in the objective, is the obvious fix.

Seeding from a giant champion works, slowly

Seeding the follow-up run directly from the 872-line champion made every reflection prompt enormous. Twelve proposals in a row were rejected; each reflection call ran for minutes and flirted with the timeout that had already killed one run. The interim verdict was “diminishing returns” — and that verdict was wrong. It just took about 300 evaluations to cash out, at which point the run produced the best generalist we have.

The cheaper version of the same idea was tested next, and it worked: seed from the small original router, so reflection stays fast, but carry the discovered structure — bimodal prior, per-edge liquidity bounds — in the background prompt. Same knowledge, a fraction of the prompt, nearly the same router at the end of it (§05).

Two failure modes worth designing against

A pathological candidate spun in an infinite loop, blew the subprocess timeout, and the exception propagated far enough to end a run at 135 of its 400 evaluations. The harness now scores a hung candidate zero instead of crashing. The same fragility still exists one layer up: a slow or failed reflection call should degrade to “no proposal this round” rather than terminate the search.

And a scoring caution that applies to anything on the live run panel: GEPA's own per-minibatch best score runs optimistically high — 0.97 and 0.99 in the last two runs — because it is measured on the training minibatches it selected. Champions are decided by separate held-out runs, never by that number.