# Findings — what the evolved routers kept, dropped, and invented
The definitive write-up of the lnd × GEPA routing evolution effort: mainnet validation, the paradigm-over-parameters result, and an anatomy of the evolved algorithms against lnd's.

Skip to content
Findings/lnd × GEPA routing evolution/31 July 2026

# What the evolved routers kept, dropped, and invented

Thirty-one experiments in, the shape of the result is clear. On a real mainnet graph snapshot, LLM-evolved routers match lnd's success rate using 8.6× fewer HTLC attempts on a perfect failure channel — a ratio §12 has since retired, because once the channel is degraded the edge converts into success instead. Either way the structure they arrived at is not a tuned version of lnd's. It is a different way of remembering what the network told you.

sources simulation/lab/experiments champions hb1 · mx_c3, title defended (exp-020) status validated · de-circularised · attribution-tested (exp-019) · engine-adjudicated (exp-018, exp-024) · distilled (exp-021) · priced (exp-023, exp-025) · integrated (exp-027) · foreign-balance-tested (exp-029) · mechanism-closed (exp-030) integration interval-lnd 14/14 over stock lnd, the release candidate (§19), champion-grade on a balance sheet nobody here drew (§21) evolution at its measured boundary, the compose world closed at any seed and any practical budget (§23)

#### corrections to our own record

Five claims this project made about itself do not survive scrutiny. They are listed here rather than quietly edited out, because the scoreboards do not move and the mechanism stories are narrower than we first told them. The long version, mechanism by mechanism, is simulation/lab/WHY.md §0.

The bimodal prior was in the prompt. Since its earliest committed version the reflection LM's background block has stated, under a heading reading environment truths worth exploiting, that hidden liquidity is drawn mostly from a bimodal distribution. So “rediscovered from failure traces alone” is wrong. What survives is the shape — an exponential low mode plus a logistic cliff, written directly as a probability rather than derived by integration — its constants, and the interval machinery built on top. Downgrade the claim to: told that liquidity is bimodal, evolution produced a calibrated bimodal prior and then went well past it.

The evolved prior fits our generator, not the network. sim_liquidity.go draws hidden balances as ExpFloat64() * 0.05 of capacity, and the evolved low-mode scales are 0.055 for atomic1, 0.025 for hb1, 0.018 for mx_c3. That is what fitting a generative model looks like when you can see the samples, and it bounds the claim: the champions learned this simulator's liquidity constant. The mainnet tier is the real 12,161-node topology with the real policies, and then it overwrites the balances with that same generator. Real topology, real fees, our liquidity. (Half of this is now closed: §11 re-ran the field across thirteen generator families the constants were never fit to, and the ordering held on all thirteen. What stays open is that every one of those families is still a distribution we chose.)

§10's mechanism was wrong when first published here. The served-weights section originally explained lnd's loss by saying its failure penalty carries no amount and suppresses a corridor for every payment size. It does not: probability_apriori.go:363 returns the unpenalized prior whenever the amount is below the recorded failure amount. An independent review caught it by reading the estimator instead of the summary. Two further guesses — node-level contagion, then staleness — were also wrong, each killed by a specific control. The surviving explanation is volume, and it is in §10 along with the three discarded ones. The measured result never changed; only the story about it did.

The paradigm ceiling is confounded with the optimizer. Every run in this project used one engine, gepa. Three lineages converging on one band is evidence about that engine's attractor as much as about the problem, and the GEPA team's own multi-engine results — no engine dominant, each winning about a third of problems, engine-switching breaking plateaus — make the alternative live. Underdetermined rather than wrong; the run that would settle it is specified in the exp-011 writeup. (That run has since happened: given the same seed, corpus and eval budget, neither alternative engine reached the band, let alone broke it, so at practical budgets it is not a gepa artifact (§13). The follow-up it specified has run too — the same alternative at ten times the budget converges to a shelf below where gepa lands on a tenth of the evaluations, so the band is not budget starvation either (§15). Both halves of this correction are now closed; what stays open is whether the band is a property of the problem or of the paradigm class these engines reach.)

lnd's decay never fires on the static tiers. Mission control heals a penalty on a clock, and the corpora behind most of the numbers on this page carry no clock section at all, so its pair entries are permanent zeros. That is a fair reading of lnd's own defaults on a static world rather than a handicap we imposed — and where a clock does run, on the drift and atomic tiers, decay is live and still does not close the gap.

01

## Validated on lnd's home turf

The closing experiment took the champions off synthetic graphs and put them on a real one: a 12,161-node, 39,659-channel mainnet describegraph snapshot.

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.

Attempts per payment on the mainnet snapshot Fig. 1 · lower is better
Success rates on this graph are close together — lnd 0.790, the hand-written seed 0.820, both evolved champions 0.810 — so nearly the whole difference between them is how much probing it takes to get there. lnd spends roughly twenty in-flight attempts per payment; the evolved routers spend two. Read this ratio as a perfect-channel figure: §12 retired it, because under realistic attribution degradation the edge stops being an attempt edge and becomes a success one.

exp-009 · 100 payments, 100k–2M sat, up to 8 MPP parts
router | objective | success | attempts / payment
--- | --- | --- | ---
lnd production stackDijkstra + mission control, tuned for this graph | 0.694 | 0.790 | 19.8
hand-written seed~300 lines, cheapest path + blacklist | 0.762 | 0.820 | 6.1
hb1evolved, 872 lines | 0.790 | 0.810 | 2.3
mx_c3evolved, 1,525 lines | 0.791 | 0.810 | 2.3

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.

#### caveats, stated plainly

One snapshot, one unusually well-connected source, and no background traffic — nobody else's payments move liquidity between our attempts. The simulator's remaining fidelity gaps are tracked and unfixed. What can be said is narrower than “these routers are better on mainnet”: on this graph, under this sender model, every validation tier we have points the same direction.

02

## The paradigm is the lever, not the parameters

The most useful result of the project is a negative one, and it arrived early enough to redirect everything after 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.

#### the conclusion that set the agenda

A tuned or untuned lnd loses to a paradigm-different toy. The bottleneck is the algorithm, not its knobs — so stop searching the parameter space and start searching the space of algorithms.

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.

03

## Three tiers of held-out evidence

A sealed synthetic test set, a corpus of topologies the winners never trained on, and the mainnet snapshot. The ranking does not change.

Composite objective, by router and tier Fig. 2 · higher is better
evolved by GEPA baseline (lnd, or hand-written)
Objective is success − 0.01·min(extra attempts, 15) − 0.00002·min(fee ppm, 5000), so a router is rewarded for delivering money and penalised, mildly, for burning attempts and fees to do it. The absolute levels differ wildly between tiers because the tiers differ in difficulty; what matters is that the order within each is the same.
Table view, with the synthetic combined average

router | mainnet | hard sealed test | out-of-distribution | synthetic combined
--- | --- | --- | --- | ---
lnd production stack | 0.694 | 0.309 | 0.357 | 0.333
hand-written seed | 0.762 | 0.530 | 0.487 | 0.509
hb1 sharp-bimodal specialist · family-tier edges only (exp-020) | 0.790 | 0.586 | 0.545 | 0.565
mx_c3 generalist — title defended (exp-020) | 0.791 | 0.583 | 0.581 | 0.582

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.

04

## Anatomy: dropped, rediscovered, invented

Reading the champions' source against lnd's is where the research value is. Three things happened, and only one of them is a tuning story.

Droppedentirely

#### lnd today

Mission control keeps a global history of node-pair outcomes and feeds two probability estimators, with node-level extrapolation dragging a whole node's channels down when one of them fails.

Time-decayed penalties. A failure heals over PenaltyHalfLife — one hour by default — and the bimodal estimator's liquidity window relaxes back to full capacity over seven days.

#### evolved champions

Neither exists. Grep both champion files for MissionControl, for any estimator, for time.Now, for decay: zero hits in 872 and 1,525 lines respectively.

The routers carry no clock at all. Knowledge is never forgotten because it was old — only revised because new evidence contradicted it.

Rediscoveredindependently

#### lnd today

The bimodal estimator encodes an analytically derived hypothesis: channel funds tend to sit at one end, so balance density looks like e^(−x/s) + e^((x−c)/s). It is opt-in, and it took a paper to justify.

#### evolved champions

The same hypothesis, arrived at from failure traces alone, written as an explicit function of amount over capacity: a decaying-exponential low mode plus a logistic cliff near capacity, clamped to [0.005, 0.985].

Nobody told the reflection LM that Lightning liquidity is bimodal. It inferred the shape from which amounts died where, and hard-coded its own version. See Fig. 4. That first sentence is retracted: the harness prompt did say so, and what survives is the shape and the constants (corrections).

Inventedthe structural break

#### lnd today

A failure becomes a penalty on a node pair: a scalar that makes that hop look expensive, decaying back toward neutral on a clock. Confidence is a function of age.

#### evolved champions

A failure becomes a bound on liquidity. Each directed channel carries an interval — lowerOK, the largest amount proven to pass, and upperFail, the smallest proven to fail — plus a confidence-weighted point estimate between them.

Below lowerOK probability is ≈0.995; at or above upperFail it is 0; in between the prior blends with the estimate. Confidence comes from success and failure counts, never from elapsed time. It is closer to Pickhardt-style liquidity bounds than to lnd's pair-penalty model.

Two ways to remember a failed attempt Fig. 3 · schematic
scroll the diagram sideways →
The structural break in one picture. lnd stores how bad a hop is right now and lets that fade; the evolved routers store what has been proven about this channel and only revise it on contradiction. More attempts narrow the interval instead of deepening a penalty — which is also where the attempt reduction comes from, since a router that knows an amount is impossible never retries it, and mx_c3 additionally retries at a lower amount rather than blacklisting the hop outright.
The rediscovered bimodal prior Fig. 4 · the champions' own formula, plotted
scroll the chart sideways →
the prior, exactly as the champions compute it the exponential low-mode term on its own
With no observations for a channel, this curve is the champions' entire belief about it: near-certainty for dust, a fast collapse to a flat middle around 0.53, then a cliff at 92% of capacity. It is the bimodal hypothesis — funds sit at one end — restated as a cheap closed-form function, inferred from which amounts died where rather than derived from a balance density model. The result is clamped to [0.005, 0.985] defensively; with these constants neither bound is ever reached.

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 honest reading of “no time logic”

lnd's decay exists for a real reason: on a live network other people's payments move liquidity while you are idle, so stale knowledge should fade. The simulator these champions evolved in had no background traffic and no virtual clock — hidden balances changed only when our own payments moved them. In that world hard evidence bounds are strictly optimal and decay can only destroy true information, so evolution was right about the environment it was given, and that is not the same as being right about mainnet.

What plausibly transfers is the within-payment case: over seconds and minutes, interval beliefs look better than a fading penalty, and lnd's one-hour half-life mostly matters across payments. That follow-up has now run. exp-008 added background traffic and a virtual clock, and time-awareness did re-evolve: the winner stamps every belief, halves its confidence every 35 virtual minutes and expires hard bounds at twenty. It then lost to these time-less champions on all four held-out tiers, drift included. lnd's rationale for decay is validated; its necessity is not.

05

## The paradigm ceiling: three lineages, one band

A third router was bred from scratch with the champions' discoveries handed over as four sentences of prose. It reached them, and it did not pass them. That is a finding about the design, not about the run.

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.

Three independent lineages land in the same band Fig. 5 · higher is better
evolved by GEPA baseline (lnd, or hand-written)
Each dot is one router's objective averaged over all three held-out tiers — hard sealed test, out-of-distribution corpus-v2, mainnet snapshot — so this is a wider average than the synthetic combined column in §03. The axis starts at 0.40, not zero, because the point of the figure is the gap that is not there: hb1, mx_c3 and gen2 span 0.638 to 0.652, while the two baselines sit 0.05 and 0.19 below them. Three roads, same destination.
Table view, tier by tier

exp-011 · held-out composite objective. Combined is the mean of all three tiers.
router | hard sealed test | out-of-distribution | mainnet | combined
--- | --- | --- | --- | ---
lnd production stack | 0.309 | 0.357 | 0.694 | 0.453
hand-written seed | 0.530 | 0.487 | 0.762 | 0.593
hb1 lineage 1 · 872 lines | 0.586 | 0.545 | 0.790 | 0.640
mx_c3 lineage 2 · 1,525 lines | 0.583 | 0.581 | 0.791 | 0.652
gen2 lineage 3 · 931 lines, prose-seeded | 0.565 | 0.563 | 0.787 | 0.638

### 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.

#### what a ceiling means here

More evaluations in this environment buy nothing. The interval-belief design is a local optimum for static worlds, and three independent runs now agree on where its edge is. The next lever is not a bigger budget or a better reflection prompt: it is changing what the environment asks for. Champions of record therefore stay hb1 and mx_c3; gen2 is kept as reference source, not promoted. One caveat rode along unstated until exp-018 tested it — all three lineages were bred by the same optimizer, and handing two other engines the identical seed, corpus and budget produced no router at all, so at practical budgets the band is not an artifact of gepa (§13).

#### how strong this evidence actually is

Three samples, not a proof. Convergence could reflect a shared bias in the reflection model as easily as a true optimum, and all three runs drew on background prompts that mention the same prior work — the lineages are independent in their code, not in their culture. gen2 also blew past its own lean-code instruction at 931 lines, so “stay small” is guidance the loop does not enforce. What the result supports is narrow and useful: on these corpora, this paradigm's headroom is spent.

The direct test of that claim was exp-008, which changed the environment rather than the budget. The ceiling held: a router bred on drift, with a clock it invented itself, did not pass the champions even on drift — and gen2, which never saw drift, outscores it there.

06

## Splitting pressure: three proposers, one mechanism, no new champion

The ceiling said change the environment, so exp-010 built one where unequal splitting is the difference between paying and failing — then pointed three different reflection models at it. All three invented joint route-set planning. None of them took the crown.

3lineages
independent proposers — codex/gpt-5.6-sol, Opus 5 at default effort, Opus 5 at medium — on the same corpus, budget and seed, each of which evolved joint route-set planning
the environment elicited the mechanism three times over
+0.005vs mx_c3
the Opus-default winner on the splitting validation set — the first evolved candidate in this project's history to reach a champion on any tier
p = 0.07 · raw success 0.958 against 0.917
0.303vs 0.583
the same router against mx_c3 on the sealed hard test: a collapse the moment it leaves the corridors it was bred in
depth bought a specialist, not a generalist

### 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.

exp-010 · composite objective on five held-out tiers. Each evolved arm carries its paired delta against mx_c3 — per-file differences, two-sided sign test.
router | split validation | split test | hard test | OOD v2 | mainnet
--- | --- | --- | --- | --- | ---
lnd production stackunusually strong on this corpus, at 23.4 attempts | 0.782 | 0.837 | 0.309 | 0.357 | 0.694
codex arm976 lines · one-step lookahead | 0.809−0.025 · p .008 | 0.810−0.067 · p .008 | 0.536−0.048 · p .021 | 0.494−0.086 · p .021 | 0.743−0.048 · p .039
Opus 5, default effort1,931 lines · persistent flow plans | 0.839+0.005 · p .07 | 0.841−0.035 · p .07 | 0.303−0.280 · p .002 | 0.483−0.098 · p .34 | 0.757−0.033 · p .18
Opus 5, medium effortup-front corridor-sized shard sets | 0.782−0.053 · p .008 | 0.743−0.133 · p .008 | 0.299−0.285 · p .002 | 0.420−0.161 · p .021 | 0.766−0.025 · p .109
mx_c3champion of record · the baseline every delta is measured against | 0.835 | 0.876 | 0.583 | 0.581 | 0.791

### 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 three lineages settle

Champions of record are unchanged: hb1 and mx_c3, now validated against three independent proposer lineages on an environment purpose-built to unseat them. The recurring law of this project takes its sharpest form here — environments elicit mechanisms, budgets decide champions — with one clause added. Proposer strength moves a candidate along the specialist–generalist axis; it does not lift the whole curve.

#### the caveat that was registered before the verdicts

Every file in this corpus carries two cheap probes and one ambitious payment, so two-thirds of the success term is free and per-file scores are nearly binary. At a reflection minibatch of three the acceptance signal quantises around 0.111, while the spread actually being selected for — attempt efficiency between routers that mostly succeed anyway — is worth at most 0.15. That was written down mid-run, before any verdict was read, and it stands over all three of them: selection noise here plausibly exceeds signal, so none of these results is evidence that joint planning cannot win.

exp-010b is the fix, and it is designed: a higher-resolution corpus, one probe pair against eight to ten graded payments per file, plus simultaneous shard commitment so that sequential adaptivity stops being free. The bonus question it inherits is whether the persistent-plan machinery pays off once a router can no longer watch one shard land before choosing the next.

It has since been built and run, and the answer to both halves is in §07: the arena reordered the field before evolution touched it, the persistent-plan machinery came back stronger in both arms, and the champion held anyway.

07

## The honest arena: atomic commitment, and the fifth challenge

The splitting corpus let a router probe with one shard, watch it land, and then choose the next one in a world that had politely stopped moving. exp-010b took the subsidy away — shards hold liquidity until the whole payment settles, siblings contend for what is held, and the network drifts on every attempt. The field reordered. The champion did not move.

105attempts
attempts per payment for lnd's production stack once shards commit atomically, against 23 on the same topology with instant settlement — its divide-and-conquer probe ladder is exactly what the new arena taxes
second place to last · objective 0.338
1.6att/pmt
the codex winner on the mainnet snapshot: the most attempt-frugal router this project has ever measured, below the champions' 2.3, at an objective dead even with mx_c3
delta −0.001 · the first challenger with no collapse tier
−0.044home tier
the best challenger's remaining deficit on held-out atomic test, on an arena designed expressly to charge the champion's reactive ladder what it costs on mainnet
p = 0.07 · fifth direct challenge to mx_c3, fifth hold

### 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.

exp-010b · baseline on the atomic corpus, before any evolution. Seven routers rebuilt against the same tree; attempts are per payment on the held-out tier.
router | atomic val | atomic test | test success | test attempts
--- | --- | --- | --- | ---
lnd production stacksecond-best on the same topology when shards settled instantly | 0.286 | 0.338 | 0.500 | 104.8
hand-written seed~300 lines | 0.389 | 0.385 | 0.536 | 56.5
split2exp-010 codex arm · one-step lookahead | 0.356 | 0.391 | 0.554 | 26.9
opusmed1exp-010 Opus medium arm | 0.357 | 0.373 | 0.536 | 28.0
opus1exp-010 Opus default arm · persistent flow plans, never saw atomic semantics | 0.429 | 0.425 | 0.571 | 23.5
hb1champion · 872 lines | 0.430 | 0.444 | 0.554 | 10.7
mx_c3champion of record · ties hb1 exactly on test, +0.001 at p .73 | 0.442 | 0.444 | 0.571 | 12.6

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.

exp-010b · composite objective on six held-out tiers, all routers rebuilt on the current tree. Paired deltas against mx_c3, two-sided sign test over per-file differences. The scratch legacy corpora were regenerated after a reboot, so read the deltas inside this table rather than comparing levels against §06.
router | atomic val | atomic test | split test | hard test | OOD v2 | mainnet
--- | --- | --- | --- | --- | --- | ---
opus1unevolved challenger · bred on the non-atomic corpus | 0.429−0.013 · p .73 | 0.425−0.019 · p .29 | 0.841−0.035 · p .07 | 0.284−0.195 · p .18 | 0.483−0.098 · p .34 | 0.757−0.033 · p .18
atomic1codex arm · 1,031 lines · memory + reservation ledger | 0.426−0.016 · p .29 | 0.400−0.044 · p .07 | 0.825−0.051 · p .07 | 0.417−0.062 · p .75 | 0.544−0.036 · p .75 | 0.790−0.001 · p .039
atomicopus1Opus default arm · 987 lines · bound-relaxing re-probe | 0.374−0.067 · p .29 | 0.391−0.053 · p .008 | 0.711−0.165 · p .008 | 0.247−0.232 · p .109 | 0.367−0.214 · p .109 | 0.738−0.053 · p .18
mx_c3champion of record · the baseline every delta is measured against | 0.442 | 0.444 | 0.876 | 0.479 | 0.581 | 0.791

### 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.

#### what the fifth challenge settles

Champions of record are unchanged: hb1 and mx_c3. The arena was designed against them specifically — the whole point was to charge the reactive evidence ladder for the sequential probing it enjoys for free — and the ladder, taxed and un-subsidised, still leads every tier. What changed is the shape of the frontier rather than its height. The nearest challenger is now a generalist too, every gap outside the home tier is inside the noise, and the home tier's own gap sits at p = 0.07. The program law takes one more clause: environments elicit mechanisms, budgets decide champions, and proposer strength interacts with environment variance.

#### the proposer A/B flipped

In exp-010, on a static corpus, Opus 5 at default effort built the deepest planner of the three arms and beat codex on the corpus both were bred for (§06). Here, on the same budget with the only change being churn and contention, codex wins every tier and the Opus winner is the weakest router of the family. The consistent reading is that deliberate proposers take large architectural steps: those pay in a low-noise environment, where a big correct step is retained, and misfire when minibatch acceptance is noisy enough that a big step is kept or dropped for the wrong reason. Codex's smaller steps ride the noise better. Proposer choice is not a fixed ranking; it interacts with how loud the environment is.

Both arms ran fully sealed, incidentally — 400 evaluations each with zero degraded reflections and a zero instruction-leak canary, the first runs in the program to manage that.

#### next: the measurement channel, not a harsher arena

Three environment levers have now been pulled — drift, mandatory unequal splitting, atomic commitment — and each elicited the mechanism it was built to elicit without changing the ranking. That is enough evidence to stop pulling. The next two experiments go after the two things never yet varied. Degraded attribution: the simulator tells a router exactly which hop failed at what amount, which is a precision paradise compared to mainnet, and the advisor's read is that some of the champions' margin lives there. It is the decisive pre-upstream test. exp-012, cold cache against hot: an unscored warmup phase, staleness under drift, and third-party weights, which is where the structural split between the lineages finally gets priced — every Opus winner keeps no cross-payment state at all, while every codex router carries a belief map from one payment to the next.

Both have since run. The degraded-attribution ladder is §12, and it cost this page its headline ratio while leaving the ordering intact.

That one has since run, and the split got priced: §08. Under a stale cache the memory-carrying hybrid holds its score while both champions collapse, which is the first statistically significant win over a champion this project has recorded.

08

## Cold cache, hot load: what is a mission control worth?

Every number published above is a cold-start number. A production node's mission control holds thousands of observations, and that regime had never been tested here — so exp-012 tested it four ways, found no hot-cache regime anywhere, and turned up one upstream-shaped result on the way.

11.9×
lnd's attempt cost relative to the champion on the last three payments of a mainnet batch, up from 4.7× on the first three — its disadvantage grows with experience rather than shrinking
the warmup is not slow · it has not started
+0.428vs mx_c3
atomic1's paired margin on mainnet after 400 stale warmup payments — the first statistically significant win over a champion in this project's history
p = 0.002 · a robustness axis, not the standing objective
0.012floor
the probability atomic1 clamps a stale bound to, where both champions clamp to a hard zero — the entire difference between shrugging at a stale cache and abandoning the network
a small change to an existing estimator

### 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.

exp-012 part 1 · attempts per payment relative to mx_c3 on the same payment, averaged over the first three and the last three payments of each ten-payment file. Lower is better; the champion is 1.00× by construction.
router | mainnet first 3 | mainnet last 3 | hard first 3 | hard last 3
--- | --- | --- | --- | ---
lnd production stack10.1 → 31.2 absolute attempts on mainnet | 4.72× | 11.88× | 5.10× | 4.42×
hand-written seed~300 lines | 1.68× | 4.44× | 4.29× | 7.44×
hb1champion · stateless across payments | 0.91× | 0.99× | 1.06× | 1.34×
mx_c3champion of record · 2.4 → 2.6 absolute attempts on mainnet | 1.00× | 1.00× | 1.00× | 1.00×
atomic1the only router carrying cross-payment memory | 0.72× | 0.58× | 1.56× | 0.73×
opus1exp-010 Opus arm · fresh router per payment | 2.08× | 3.35× | 1.33× | 1.52×

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.

exp-012 part 2 · mainnet objective after an unscored warmup with the network's liquidity restored, so only staleness varies. Attempts per payment in the sub-line; atomic1 also carries its paired delta against mx_c3, two-sided sign test over per-file differences.
router | cold | stale 25 | stale 100 | stale 400
--- | --- | --- | --- | ---
lnd production stackpair entries are permanent zeros on this tier | 0.69419.8 att | 0.61719.6 att | 0.37726.9 att | 0.22832.4 att
hb1champion · hard upperFail zero | 0.7902.3 att | 0.7381.6 att | 0.5501.4 att | 0.3470.6 att
mx_c3champion of record · hard upperFail zero | 0.7912.3 att | 0.7341.8 att | 0.5501.2 att | 0.3470.6 att
atomic1persisted bounds clamp to a 0.012 floor | 0.7901.6 att | 0.7971.8 att · +0.063 p .004 | 0.7832.2 att · +0.233 p .002 | 0.7752.0 att · +0.428 p .002

### 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.

#### the one change this argues for upstream

A served weight cache is stale by construction — that is what serving it means. These measurements say the consumer's staleness policy dominates the value of the cache, and that the safe policy is a probability floor on learned evidence, never a hard zero. That is a small change to an estimator lnd already ships, not a new paradigm, and it is the most directly upstream-shaped result the program has produced. Champions of record are unchanged: this is a robustness axis, not the standing objective.

Superseded as the leading candidate: the patch that is actually PR-ready is exp-021's soft_unknown, which is written, measured on real corpora and inert when off (§14). The probability floor described here remains untested as a diff.

### 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.

#### what that costs us backwards

exp-008 concluded that time-decay “buys nothing at realistic churn.” The conclusion is sound about our churn, and our churn is far gentler than intended. The honest restatement: decay buys nothing at the weak churn this simulator generates, and the drift experiment never reached a regime where evidence genuinely goes stale. The per-attempt drift in the atomic arena (§07) comes from the same engine and inherits the same caveat. Make background traffic actually settle, aim some of it at the corridors under test, and only then re-run this sweep and exp-008's decay question underneath it.

### 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.

#### what this negative does not cover

Every arm here derives knowledge from payments, and payments cost liquidity. That makes free knowledge unconstructible in the current simulator: the drain arm pays in depletion, the restore arm pays in staleness, the probe arm pays in both, just less. A served weight cache in the actual proposal costs its consumer nothing — it arrives over an API. Measuring that needs beliefs injected straight into mission control, or into a candidate's state, from a file, with no payments sent at all. Until that exists, exp-012's negative is a statement about probe-warming, not about weight-serving.

09

## The knob we never turned

This project has repeated since exp-002 that the paradigm is the lever and not the knobs. The one configuration that would make lnd's own machinery match this environment had never been evaluated. It has now, at seven scales, and the claim survives for a stated reason rather than an absence of evidence.

7scales
bimodal configurations bracketing the environment-matched scale by an order of magnitude either way, against lnd's shipping apriori default and the champion, on two sealed tiers
none of them beats lnd's own default
2.5× attempts
what a better prior costs lnd on the hard tier: success rises 0.421 → 0.478 while attempts go 30.9 → 77, because the estimator changes which route it retries and never how much it sends
a net loss under an objective that charges for attempts
0.02vs 0.20
the objective the estimator swap is worth, against what the paradigm difference between lnd and the champions is worth on the same corpora
the estimator is not the part that needs changing

### 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.

exp-002b · seven bimodal scales against lnd's shipping apriori default and the champion. Same binary, same corpora, same objective; only --params differs. The corpora were regenerated after a reboot, so read the levels inside this table rather than against earlier sections.
router | hard obj | hard succ | hard att | v2 obj | v2 succ | v2 att
--- | --- | --- | --- | --- | --- | ---
lnd apriorithe estimator lnd actually ships | 0.298 | 0.421 | 30.9 | 0.357 | 0.525 | 58.8
bimodal 10Mbest bimodal on v2 | 0.259 | 0.429 | 63.9 | 0.345 | 0.528 | 73.3
bimodal 50M | 0.261 | 0.456 | 77.7 | 0.319 | 0.518 | 76.0
bimodal 100Menvironment-matched on hard · 5% of a 2M sat channel | 0.261 | 0.456 | 78.7 | 0.330 | 0.528 | 77.4
bimodal 150Menvironment-matched on v2 · 5% of a 3M sat channel | 0.273 | 0.467 | 78.9 | 0.330 | 0.518 | 81.2
bimodal 300Mlnd's own default scale · the staged baseline | 0.280 | 0.478 | 76.9 | 0.330 | 0.528 | 79.0
bimodal 1000Mbest bimodal on hard | 0.283 | 0.478 | 77.2 | 0.331 | 0.528 | 79.2
mx_c3champion of record · same corpora, same objective | 0.479 | 0.592 | 8.1 | 0.581 | 0.695 | 8.4

### 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 honest framing is stronger than the old one

We are no longer saying we failed to tune lnd into competitiveness. We are saying that lnd's own bimodal hypothesis, given its best scale for this environment, buys success at double the attempts and still loses by a wide margin, because the estimator is not the part that needs changing. The estimator swap is worth at most 0.02 of objective; the paradigm difference is worth 0.18 to 0.22. The part that needs changing is that nothing in the retry loop reads FailAmt to size the next attempt — and mission control already records it.

That prescription has since been tested and it is wrong, or at least inert. exp-021 built three amount policies that read the bound, and each reduced to the geometric descent lnd's blind halving already performs at a faster ratio and no HTLC cost. The missing piece is not in the retry loop at all (§14).

10

## Free knowledge helps the champions and hurts lnd

Give three routers the same observations from the same third-party node, costing them nothing, and two of them get better while lnd gets worse. The split is entirely in the failure evidence, and it says what a weight-serving API can safely serve to whom. The explanation below is the fourth attempt at the mechanism; the three failed ones are kept in place.

+0.055atomic1
objective gained from a stranger's observations, with no payment sent to earn them. mx_c3 gains +0.031 and nearly halves its attempts, 8.1 to 4.4
served knowledge is worth real objective to a bound-keeper
−0.029lnd
what the identical file does to the production stack, whose attempts rise from 30.9 to 33.8 rather than falling
accurate free information makes lnd worse
9 of 10files
how often lnd is worse when only the FAILURE observations are imported: −0.039, a confidence interval that excludes zero, and the whole of its loss
successes help everyone; failures divide the field

### 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.

exp-016 · the volume control. Staleness and volume were confounded in the first comparison; matching the counts separates them.
failure evidence imported | count | Δ vs cold | worse on
--- | --- | --- | ---
stale, full | 2,808 | −0.046 | 4/10
stale, size-matched | 232 | −0.003 | 1/10
fresh, 1-payment server | 232 | +0.000 | 0/10

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).

exp-016 · ten sealed hard-tier files, third-party observations imported before the first route request. Paired bootstrap confidence intervals over per-file differences; the sign test needs 9 of 10 to reach p<0.05 at this size, so it and the interval disagree where noted.
router | arm | objective | attempts | Δ vs cold | 95% CI
--- | --- | --- | --- | --- | ---
lnd | cold | 0.298 | 30.9 | — | —
lnd | all | 0.268 | 33.8 | −0.029 | [−0.079, +0.001]
lnd | success only | 0.301 | 27.5 | +0.003 | [−0.052, +0.051]
lnd | failure only | 0.259 | 27.8 | −0.039 | [−0.077, −0.006]
mx_c3 | cold | 0.479 | 8.1 | — | —
mx_c3 | all | 0.510 | 4.4 | +0.031 | [+0.007, +0.061]
atomic1 | cold | 0.417 | 7.1 | — | —
atomic1 | all | 0.472 | 5.1 | +0.055 | [+0.010, +0.106]

### 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.

Caveats. One tier, ten files, one server per file chosen by index rather than by connectivity. Server coverage ranged from 0 to 2,111 observations, so who serves matters as much as what is served. The server's observations are stale by construction, since its own run moved the liquidity it was observing — these are lower bounds on the value of fresh knowledge.

11

## Thirteen worlds the constants were never fit to

The worst thing this project knows about itself is in §00: the evolved priors fit our own liquidity generator. exp-017 parameterised that generator and moved the world underneath every router — thirteen paired tiers, 650 runs, including two where the bimodal hypothesis the priors encode is simply false. The ordering did not move.

13 / 13tiers
tiers on which lnd finishes fifth of five and an evolved router finishes first, across wrong bimodal scales, polynomial tails, uniform balances, a topology-correlated drain, two amount distributions and four re-liquified mainnets
hb1 − lnd carries a CI excluding zero on 12 of 13
0.229 → 0.147seed vs lnd
the hand-written seed's margin compressing along the same ladder that compresses the champions' — and the seed predates every constant under suspicion
the control that kills the overfitting reading
4 → 1atomic1 rank
atomic1's rank as the liquidity family flattens away from the fitted shape, monotone across six tiers, with the mirror-image collapse on the sharpest bimodal world
the generator named a specialist we did not know we had

### 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.

exp-017 · composite objective by tier, with success and attempts per payment underneath. Ten files per tier, identical across routers; the leader of each tier is bold. The control rows are the unmodified generator, so they are the worlds every earlier section on this page was scored in.
tier | lnd | seed | hb1 | mx_c3 | atomic1
--- | --- | --- | --- | --- | ---
liq-bimodal 0.01the fitted shape, five times sharper | 0.1430.30 succ · 43.9 att | 0.3720.52 succ · 42.3 att | 0.441 0.55 succ · 8.4 att | 0.4320.55 succ · 9.1 att | 0.2660.36 succ · 10.4 att
liq-bimodal control the generator every earlier section used | 0.1920.37 succ · 40.0 att | 0.3970.55 succ · 29.1 att | 0.471 0.58 succ · 8.6 att | 0.4620.58 succ · 10.0 att | 0.3750.48 succ · 8.0 att
liq-bimodal 0.2four times flatter | 0.3180.48 succ · 43.1 att | 0.4720.62 succ · 17.7 att | 0.551 0.66 succ · 6.3 att | 0.5320.66 succ · 9.9 att | 0.5140.62 succ · 6.6 att
liq-beta 0.3 0.3U-shaped, polynomial tails | 0.2400.40 succ · 48.1 att | 0.4340.59 succ · 21.0 att | 0.4890.61 succ · 6.8 att | 0.4810.61 succ · 7.9 att | 0.523 0.64 succ · 8.0 att
liq-beta 2 2unimodal and centred — the bimodal hypothesis is false here | 0.3700.52 succ · 60.2 att | 0.5310.64 succ · 8.4 att | 0.5740.66 succ · 4.4 att | 0.5460.64 succ · 5.0 att | 0.644 0.72 succ · 3.6 att
liq-uniformno modes at all | 0.3690.53 succ · 52.0 att | 0.5160.63 succ · 10.0 att | 0.5790.67 succ · 4.7 att | 0.5540.65 succ · 5.3 att | 0.626 0.71 succ · 4.3 att
liq-hubdrain 0.05drain faces the higher-degree node · underpowered, see below | 0.2120.34 succ · 30.5 att | 0.2380.38 succ · 39.9 att | 0.3030.42 succ · 11.7 att | 0.2980.42 succ · 13.1 att | 0.306 0.41 succ · 7.6 att
amt-lognormalamounts moved, liquidity at the control | 0.1850.36 succ · 33.5 att | 0.2820.43 succ · 31.6 att | 0.395 0.49 succ · 6.0 att | 0.3840.50 succ · 9.5 att | 0.3080.41 succ · 7.3 att
amt-roundround-value clustering | 0.2120.38 succ · 43.4 att | 0.3010.46 succ · 31.4 att | 0.377 0.50 succ · 9.0 att | 0.3540.49 succ · 11.3 att | 0.3070.40 succ · 7.2 att
mn-controlexp-009 untouched · the reproduction gate | 0.6940.79 succ · 19.8 att | 0.7620.82 succ · 6.1 att | 0.7900.81 succ · 2.3 att | 0.791 0.81 succ · 2.3 att | 0.7900.80 succ · 1.6 att
mn-bimodal 0.2real topology, re-liquified | 0.6570.77 succ · 19.7 att | 0.7530.80 succ · 5.2 att | 0.7810.80 succ · 2.2 att | 0.7810.80 succ · 2.3 att | 0.789 0.80 succ · 1.6 att
mn-beta 0.3 0.3real topology, re-liquified | 0.6880.79 succ · 20.9 att | 0.7960.85 succ · 5.2 att | 0.8070.83 succ · 2.3 att | 0.8070.83 succ · 2.3 att | 0.818 0.83 succ · 1.9 att
mn-uniformreal topology, re-liquified | 0.6780.79 succ · 21.4 att | 0.7860.84 succ · 5.1 att | 0.801 0.82 succ · 2.1 att | 0.8010.82 succ · 2.2 att | 0.7990.81 succ · 1.6 att

### 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.

exp-017 · margin over lnd along the liquidity ladder, sharpest world on the left, flattest on the right. The seed row is the load-bearing one: it was hand-written before any evolution ran and fits nothing.
margin vs lnd | bimodal 0.01 | control | bimodal 0.2 | beta 0.3 0.3 | beta 2 2 | uniform
--- | --- | --- | --- | --- | --- | ---
hb1 | 0.298 | 0.279 | 0.233 | 0.249 | 0.204 | 0.210
mx_c3 | 0.289 | 0.271 | 0.214 | 0.241 | 0.176 | 0.186
seed never fit to anything | 0.229 | 0.205 | 0.154 | 0.194 | 0.162 | 0.147
atomic1the one router that moves the other way | 0.123 | 0.183 | 0.195 | 0.283 | 0.274 | 0.257

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 “generalist champion” title is eroding

mx_c3 − hb1 is at or below zero on 12 of 13 tiers. The effects are tiny — never beyond |0.028| — but one clears both bars: liq-uniform at −0.025, CI [−0.064, −0.003], sign test 0 of 9, p = .004. And the tier family that anchored the title gives it no shelter: on all four mainnet families the pair ties to within 0.001, and on four of the six ladder tiers the two post identical success and differ only in attempts, with mx_c3 spending 0.7 to 3.6 more per payment.

Stacked on exp-015's fresh-corpus result — hb1 +0.009 at p = .014 over forty files — the evidence points one way: hb1 is at least mx_c3's equal everywhere we have looked recently, and better wherever they differ. This is still not a champion swap. The standing rule requires a held-out paired sweep over the full original tier set, and the OOD and splitting tiers the title was actually earned on were not in this sweep. Postscript, same day: that sweep ran (exp-020) and the title held. On the original set hb1 beats mx_c3 nowhere, while mx_c3 takes split-test unanimously — +0.062, 8 files of 8, p = .008 — the one tier where hb1 alone cannot beat lnd. The edges this section measured are real but family-specific: they do not transfer. Champions of record are unchanged: hb1 and mx_c3, with mx_c3 the generalist of record.

### 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.

#### give_up_rate does not mean what its name says

For all four candidate routers, give_up_rate == 1 − success_rate holds to three decimals on every tier. A candidate “gives up” whenever it returns failure without exhausting its attempt budget, and that is simply how candidates always fail; only lnd, which burns the budget, deviates. The field is a router-style fingerprint rather than an abandonment signal, and the warning recently wired into the evaluator on top of it fired on everything. Abandonment stays readable only jointly — low attempts and low success, as on bimodal:0.01 above — and the evaluator hint now states that rule unconditionally instead of thresholding on the field.

#### the one tier that is not evidence yet

liq-hubdrain_0.05 is underpowered and internally inconsistent at ten files. Every router collapses on it, hb1 beats lnd by only +0.091, hb1 wins 9 of 10 files at p = .021, and one file still drags the interval across zero. The first world whose liquidity is correlated with topology rather than drawn blind deserves its own experiment rather than a verdict from this one. Two other checks did pass: no tier is degenerate — no file has all five routers producing identical output, so the exp-012 multivantage trap did not recur — and fee spread is negligible everywhere, so these objective differences are entirely success and attempts.

#### what this closes, and what it leaves open

The claim that can now be made: the champion ordering, and most of the margin, survive liquidity and amount distributions the evolved constants were never fit to — including two where the bimodal hypothesis embedded in those constants is false. The paradigm, per-channel amount bounds learned from attempt evidence, is what wins; the constants' contribution is the residual atomic1's ladder exposes at the regime edges.

What stays authored is every world in this sweep, re-liquified mainnet included. They are still distributions we chose. The generator-family question is closed; the full escape from “simulator-shaped” is unchanged and now moves up the queue — degraded attribution, and offline replay against a real node's attempt stream. The first of those has since run (§12); the replay has not.

12

## The 8.6× dies, the margin survives

Every efficiency number above was measured on a failure channel that is instant, truthful and exactly attributed. Mainnet's is none of those. exp-019 built the degrader the advisor asked for — unreadable errors, plausible lies, delayed results — and ran the field up a six-level ladder. The champion ordering survives. The headline ratio does not.

+0.277 → +0.395hb1 − lnd
the champion's hard-tier margin over lnd as unreadable errors go from none to 30% — it widens, because no evolved router writes a liquidity bound from an unattributed failure
the feared collapse appears nowhere on the ladder
0.31 → 0.71lnd give-ups
what a 10% unreadable-error rate does to lnd on the hard tier; at 30%, four files of ten pin to exactly zero success
a self-contained upstream finding, independent of everything evolved
0.810 → 0.810mainnet
champion success under the degraded realistic mix, unchanged to three decimals, while lnd trades six points of success and a doubled give-up rate for its attempt drop
the edge converts from attempts into success

### 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.

exp-019 · sealed hard tier. The control column is each router's undegraded objective; every other cell is that router's change from its own control, so the columns read as damage rather than as levels.
router | control | unknown .1 | unknown .3 | shift .1 | shift .3 | realistic mix
--- | --- | --- | --- | --- | --- | ---
lnd production stackthe only router that moves in both directions | 0.309 | −0.1070.202 | −0.1470.162 | +0.0850.394 | +0.1220.431 · p .002 | −0.1210.188
hand-written seed~300 lines · ignores an unattributed failure outright | 0.530 | −0.001 | −0.004 | −0.013 | −0.040 | −0.016
hb1champion · leads this tier · soft session penalty, no interval update | 0.586 | −0.008 | −0.029 | −0.008 | −0.093 | −0.061
mx_c3champion of record | 0.583 | −0.012 | −0.064 | −0.021 | −0.042 | −0.067
atomic1marks the route suspect rather than bounding an edge | 0.510 | −0.023 | −0.098 | −0.024 | −0.085 | −0.042

exp-019 · the same ladder read as a margin. Only one level erases it, and it does so by lifting lnd rather than by hurting the champion. On the mainnet tier at the realistic mix the margins are hb1 +0.080, mx_c3 +0.077 and atomic1 +0.079 (p = .021) — everyone still clears lnd.
margin vs lnd | control | unknown .1 | unknown .3 | shift .1 | shift .3 | realistic mix
--- | --- | --- | --- | --- | --- | ---
hb1 the champion that leads this tier | +0.277 | +0.377 | +0.395 | +0.185 | +0.062CI straddles zero | +0.336

### 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.

#### the third input to one upstream patch

This is concrete, self-contained and independent of everything evolved: lnd's response to an unreadable error is aggressive enough that a modest rate of them exhausts the route set. It joins §09's estimator result and §10's served-weights result as a third finding pointing at the same file. Failure information is handled badly in both directions: the bounds are too weak when a failure is attributed, and the penalty is too strong when it is not.

That patch has since been written and measured (§14). The half addressed here — a single minimum-probability pair instead of the whole route — recovers 86 to 148% of the collapse above and is upstreamable now. The other half, teaching the retry loop to resize the payment, is a measured null.

### 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.

#### abandonment watch

The exp-013 hazard was checked at every level, and all three interval routers are clean: attempts and success move together, spend more and get less, which is degradation rather than the give-up attractor. atomic1 sits closest to the line — give-ups 0.37 → 0.45 at unknown 0.3, attempts near flat while success falls — which is consistent with the shrug-under-uncertainty policy §08 priced.

Caveats. Eight to ten files per tier. hb1's shift-level magnitudes lean on a single file, which carries 61% of the delta, though the direction holds 9 of 10. Two hard-tier files are near-degenerate for lnd under unknown errors, its success pinned at zero, which inflates the champion margins at those levels. The mainnet arm inherits the synthetic-liquidity caveat as always. And the shift-helps-lnd anomaly has neither a mainnet nor a mechanism-isolating arm yet: it is a measured fact with an unproven story attached.

13

## Three engines, one starting line

Every run in this project used one optimizer, so §05's ceiling was confounded from the day it was published. exp-018 handed the identical seed, corpus and eval budget to three engines. Only one of them produced a router at all, and the reason is not proposal quality.

3engines
gepa, meta_harness and autoresearch on the identical in-tree seed, the identical corpus-mix, and 150 evaluations enforced centrally in the eval server rather than trusted to each engine's own accounting
the arm exp-011 could not run
1iteration
what 150 evaluations buys meta_harness, which benchmarks every proposal against the full example set at 68 evaluations a time — gepa's minibatch loop stretched the same allowance across thirteen
the moat is eval efficiency, not proposal quality
2 of 3returned the seed
both claude-driven arms finished having improved on nothing: one byte-identical to the seed it started from, the other identical modulo comments, for $1.95 and $2.50 of proposer spend
contained, well-behaved, empty-handed

### 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.

exp-018 · three engines, one seed, one corpus, 150 evaluations each. The seed's own held-out test score is 0.508, which is what two of the three arms returned.
engine | validation | held-out test | evals | wall | proposer $ | produced
--- | --- | --- | --- | --- | --- | ---
gepaminibatch acceptance · 13 iterations | 0.510 | 0.556 | 150 | 9.0 h | $0 | a real 947-line candidate
meta_harnessfull-set benchmarking · 68 evals per candidate | 0.454 | 0.508 | 136 | 19 m | $1.95 | the seed, byte-identical
autoresearchbudget spent without once beating the seed | 0.454 | 0.508 | 150 | 13 m | $2.50 | the seed, modulo comments

### 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.

#### what the adjudication settles, and what it does not

At practical budgets the ~0.64 band is not a gepa artifact — the alternative engines do not break it, or reach it, or leave the starting line. That resolves the confound in §00 in gepa's favour, and it is narrower than a proof that the band is a true problem ceiling. The arm that would test that is meta_harness at roughly ten times the eval budget, or with minibatch benchmarking bolted on, and it now comes with measured cost expectations instead of a guess: about $2 and nineteen proposer minutes per swing. Specified and costed, not run. Since run, and the costing held to 3%: the arm converges by its third iteration to a shelf below gepa's own 150-evaluation result, so starvation is out and the band survives a second engine given real room (§15).

### 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.

exp-018 · omni1 on the six-tier adjudication set, paired per file against each incumbent, two-sided sign tests over per-file differences. The attempts column is omni1 against mx_c3, per payment.
tier | omni1 | Δ vs mx_c3 | Δ vs hb1 | Δ vs lnd | attempts
--- | --- | --- | --- | --- | ---
hard test | 0.581 | −0.003p .34 | −0.005p 1.0 | +0.27110/10 · p .002 | 15.8vs 10.8
out-of-distribution v2 | 0.532 | −0.048p .51 | −0.012p .75 | +0.175p .75 | 13.1vs 8.4
split testthe one tier it does not clear lnd on | 0.825 | −0.051p .07 · CI excludes zero | +0.011p .219 · CI excludes zero | −0.012p .29 | 18.8vs 10.3
drift test | 0.412 | −0.042p .22 · CI excludes zero | −0.031p .29 | +0.175p .07 | 30.5vs 13.3
atomic testhighest success of any router on the tier | 0.427 | −0.016p .73 | −0.018p .29 | +0.107p .29 | 85.8vs 12.9
mainnet | 0.776 | −0.015p .51 | −0.015p 1.0 | +0.082p .34 | 4.4vs 2.3

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.

#### the operational cost of thinking harder

The gepa arm ran its reflections at xhigh effort per the standing directive, and four of its thirteen iterations lost their proposal to the 600-second timeout, which is most of why that arm took nine hours against the others' minutes. The searcher defaults were retuned the same night: high effort, a 900-second timeout, xhigh one flag away. So even the winning arm ran below its own potential.

Caveats. One run per engine, one seed, one corpus, so engine variance is unmeasured — and exp-010b showed proposer A/Bs flipping sign between environments (§07). The claude arms' effort knobs were left at their engine defaults rather than swept. All three arms were handicapped in different ways, which is the honest description of comparing engines that disagree about what a budget is.

14

## The distillation patch: one fix lands, one theory dies

Twenty experiments established what the evolved routers do and that it works. exp-021 asks the question that matters upstream: how much of it fits into a small, reviewable diff to lnd's own stack? Two mechanisms were built, each behind its own flag. One is ready to send. The other took a theory down with it.

86–148%of the collapse recovered
what replacing lnd's unreadable-failure route nuke with a single-pair penalty gives back on §12's hard and drift ladders, with success up and give-ups down on every non-tied file
the program's first constructive upstream deliverable
+18–29attempts / payment
what that recovery costs on the hard tier — and the objective's fifteen-attempt cap cannot see a penny of it
quote success and give-ups, never the objective alone
3 → 0designs, effects
the adaptive-splitting arm: three amount policies, each reduced by its own trace to geometric descent from the failure bound — the descent lnd's blind halving already runs at the fastest ratio of any of them, free
lnd's reactive descent is already optimal for its class

### 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.

exp-021 · the patched arm against stock on the real exp-019 ladder. Recovery is the share of stock's own collapse from its clean control that the patch gives back — measured on the objective, except on mainnet, where lnd's objective rises under degradation (it stops paying for hard payments) so the share is measured on success instead. Success and give-ups are levels, stock → patched.
level | success stock → soft | give-ups stock → soft | objective recovered
--- | --- | --- | ---
unknown .1sealed hard tier | 0.293 → 0.465 | 0.707 → 0.418 | 86%
unknown .3 | 0.193 → 0.507 | 0.807 → 0.437 | 128%
realistic mixunknown .2 + shift .1 | 0.240 → 0.518 | 0.760 → 0.461 | 148%
drift mix + delayn = 8 | 0.226 → 0.444 | 0.774 → 0.556 | 97%
mainnet mixinert — 57 unknown failures across ten files | 0.730 → 0.740 | 0.270 → 0.260 | 17%of the success loss; lnd's objective did not fall on this tier

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.

exp-021 · margin over lnd at the two levels where the patch bites hardest, against stock lnd and against the patched arm. Same routers, same files, same corpora as §12's ladder.
margin vs lnd | unknown .3 vs stock | unknown .3 vs soft | drift mix vs stock | drift mix vs soft
--- | --- | --- | --- | ---
hb1leads the hard tier | +0.395 | +0.206 | +0.234 | +0.160
mx_c3champion of record | +0.357 | +0.169 | +0.216 | +0.141
hand-written seed | +0.364 | +0.175 | +0.196 | +0.122
atomic1margin gone at both levels | +0.250 | +0.062 | +0.058 | −0.017

#### the cost line, stated plainly

The patch buys success with attempts. On the hard tier it spends +18 to +29 more per payment than stock — 6.3 → 35.7 at unknown .1 — and the objective's fifteen-attempt cap is blind to all of it, so the composite flatters the patch exactly the way §13 found it flattering omni1. Every number above should be read as success and give-ups first. Whether an operator wants that trade is a policy question, not a measurement, and it belongs in the PR rather than in a benchmark table. Mainnet, meanwhile, is inert: 17% of the success loss and 7% of the give-up rise recovered, on a tier where only 57 unknown failures occur across ten files. Either the tier's give-up rise under degradation is mostly a different mechanism, or it is too small to move — which converges with exp-019b's reading.

### 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).

The descent, four ways Fig. 6 · hard-tier smoke, scenario 3

    scen3 · 1,000,000 sat to node 105, up to 16 shards · amount per attempt, sat        n

    stock  halving       1,000,847   500,424   250,212   125,106    62,553    31,277*  …    9
    rev 1  supremum      1,000,847   938,920   876,993   815,065   753,138   691,210   …   25
    rev 2  backoff .75   1,000,847   704,190   518,408   379,071   239,734   146,843   …   13
    rev 3  EV, apriori   1,000,847   750,636   500,424   375,318   250,212   125,106        6
    rev 3  EV, bimodal   1,000,847   125,106                                                2

    stock   ratios 0.500 0.500 0.500 0.500 — free, inside findPath's own retries
    rev 1   fixed step of 61,927 sat, one HTLC on the wire per step: 0.938 0.934 0.929
    rev 2   ratios 0.704 0.736 0.731 — blind descent at 0.703, slower than the 0.5 it replaces
    rev 3   apriori: argmax pinned to the top rung, i.e. revision 1 again
            bimodal: one jump to the believed rung, then stock-bimodal's retry loop

The same payment, the same corpus file, four amount policies. An asterisk marks a shard that settled; the payment fails in every column. This is the whole of Part A's finding in one exhibit: every policy we could express is geometric descent from the bound at some ratio, and the ratio lnd already uses is the fastest one, paid for with pathfinder retries rather than with HTLCs.

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.

#### what the null kills

lnd's reactive split-retry descent is already optimal for its class. Every bound-reactive amount policy we could express reduces to geometric descent from the failure bound, and lnd runs that descent at the fastest ratio of any variant, for free, inside path finding rather than on the wire. Put that beside §09 — a better estimator alone changes nothing — and both halves of the reactive distillation theory are closed. The champions' edge does not live in the reaction to failure. It must live at plan time: success-side memory (lowerOK) feeding the initial amount choice, and joint route-set construction (§06) — neither of which lnd's findPath-takes-an-amount architecture can express as a small patch. That is the honest upstream price tag, now measured rather than suspected.

### 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.

Caveats. Eight to ten files per level throughout. Objective deltas are heterogeneous across files — three or four carry each mean — even at the levels where success and give-ups move unanimously. One mainnet file shows ±0.1 attempts of nondeterminism from wall-clock penalty decay, because that tier pins no virtual clock; it changes nothing at effect scale, and it applies to every mainnet attempt figure on this page at that precision. And the above-own-control anomaly at the realistic mix is unexplained, inheriting the label §12's third finding already carries.

15

## Ten times the budget, a lower shelf

§13 left a hole in its own verdict. The alternative engines never left the starting line, so nothing had tested what one of them would do with room to move. exp-024 handed meta_harness ten times the evaluations, on the same seed and the same corpus. It iterated, it improved, and it converged — below where gepa lands on a tenth of the budget.

0.514held out, at 1,496 evals
where meta_harness settles given ten times exp-018's budget, against gepa's 0.557 on 150 evaluations and the shared seed's 0.508 — and all three well below the champions' band
the band is not an artifact of starving the alternatives
+0.0002from the last 950 evals
iterations one through three bought +0.0136 and the remaining five bought two ten-thousandths, at $1.85 to $1.99 a proposer session with every session exiting clean
convergence, not starvation — the distinction the arm existed to make
22candidates scored
full-set benchmarking costs 68 evaluations a candidate, so 1,500 evaluations bought 22 of them; gepa's minibatch loop got thirteen accept-or-reject decisions out of 150
the moat is eval efficiency, and it widens with the budget

### 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.”

exp-024 · the ceiling arm against the three exp-018 arms it is compared to. Same seed, same corpus mix, same eval server enforcing the budget centrally. Proposer spend is the reflection LM's own billing, not machine time.
arm | validation | held-out test | evals | iterations | wall | proposer $
--- | --- | --- | --- | --- | --- | ---
meta_harness ×10this run | 0.4677 | 0.5136 | 1,496 | 8 | 157m | $15.68
meta_harness ×1exp-018 | 0.4539 | 0.5082 | 136 | 1 | 19m | $1.95
gepa ×1exp-018 | 0.5102 | 0.5565 | 150 | 13 | 9.0h | $0
the shared seed | 0.4539 | 0.5082 | — | — | — | —

Where the 1,496 evaluations went Fig. 7 · meta_harness ×10, per iteration

    iteration    best validation        gain

    seed                 0.4539           —
      1                  0.4580      +0.0041
      2                  0.4626      +0.0046
      3                  0.4675      +0.0049     ← the first hour ends about here
      4                  0.4676      +0.0001
      5                  0.4677      +0.0001
      6 · 7 · 8          0.4677       0.0000     no new best, still proposing

    iterations 1–3   +0.0136
    iterations 4–8   +0.0002 over the remaining ~950 evaluations
                     three candidates proposed each, $1.85–$1.99 a session, all clean exits
    proposals seen   directional_belief · capacity_penalty · log_bimodal_cost
                     failure_code_filter · widest_path_routing

The trajectory is the finding. By iteration 3 the arm is at 0.4675 and the remaining two thirds of the budget buy two ten-thousandths. The proposer did not stall for want of money or minutes — it kept spending $1.85 to $1.99 a session and kept circling the same neighbourhood. It found the general region, bimodal-ish cost shaping, and could not find the interval apparatus from there.

### 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.

#### what this closes, and what it hands to exp-023

The exp-018 open question is closed on both halves: not a gepa artifact, and not budget starvation. No further engine adjudications are planned at any budget, which means the remaining escape hatches from the band are environment changes rather than optimizer changes — the economic-realism stages, and offline replay on real payment data. (The first of those has since run, twice: §17 measured the priced world and §18 bred in it.) The cost ledger also closed inside 3% of exp-018's estimate: eight swings at about $2 and nineteen proposer minutes each, $15.68 and 157 minutes in total, which is what a costed arm is supposed to look like when the costing was honest.

Caveats. One run, one seed, one corpus, as with every engine arm here, and exp-010b showed proposer variance flipping orderings between environments (§07). The arm ran concurrently with exp-022's evals on the same machine, which moves wall-clock and nothing else, since scores are deterministic per candidate. And ten times is not infinity: nothing here bounds what meta_harness would do with minibatch benchmarking bolted on, but that is an engine change upstream in gepa rather than an experiment this program owes.

16

## Breeding under a lying channel

Every evolution run before this one bred against a perfect failure channel. §12 showed the champions survive degradation by treating no-information as no-information — machinery that ignores the lie rather than exploiting it. exp-022 is the first run bred with the lie present. It produced the first attribution-confidence machinery this program has evolved, the flattest degradation profile ever measured here, and challenger failure number eight.

−0.013worst tier, degraded − clean
deg1's entire degradation profile across six tiers runs −0.013 to +0.000, against champions losing up to 0.067 with intervals excluding zero and lnd losing a quarter of its success on the hard tier
what it was bred for, it achieved — measurably
0of twelve tier-conditions
cells where deg1 beats a champion with a confidence interval clearing zero, in either channel condition; going the other way it loses to mx_c3 on four, unanimously on split and mainnet
no displacement, and no specialist filing either
26–92attempts per payment
on every tier, pinned past the objective's fifteen-extra-attempt cap everywhere, so the flatness costs nothing the composite is able to see
robustness bought with unbounded retrying

### 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.

exp-022 · the clean arm. Composite objective per tier, paired per file, with success and give-ups quoted together underneath because neither is readable alone on a router that never stops. The gate ran first: all five prior routers rebuilt from HEAD reproduce the exp-020 numbers on 24 of 24 cells to four decimals.
tier | lnd | hb1 | mx_c3 | deg1 | Δ deg1 − mx_c3
--- | --- | --- | --- | --- | ---
hard test | 0.3090.493 succ · 0.308 give-ups | 0.586 | 0.5830.732 · 0.268 | 0.5080.721 · 0.052 | −0.0751/9 · p .021 · CI excludes zero
out-of-distribution | 0.3570.525 succ · 0.213 give-ups | 0.545 | 0.5810.695 · 0.305 | 0.4890.681 · 0.013 | −0.0911/9 · p .021 · CI excludes zero
split test | 0.8370.958 succ · 0.000 give-ups | 0.814 | 0.8760.958 · 0.042 | 0.7880.917 · 0.000 | −0.0880/8 · p .008 · CI excludes zero
drift test | 0.2360.436 succ · 0.436 give-ups | 0.442 | 0.4540.642 · 0.358 | 0.3920.615 · 0.056 | −0.0620/6 · p .031 · CI excludes zero
atomic testits only directional lead | 0.3200.482 succ · 0.000 give-ups | 0.445 | 0.4440.571 · 0.429 | 0.4630.625 · 0.000 | +0.020p .73 · CI straddles zero
mainnetfirst evolved router below lnd here | 0.6940.790 succ · 0.130 give-ups | 0.790 | 0.7910.810 · 0.190 | 0.6790.800 · 0.090 | −0.1120/10 · p .002 · CI excludes zero

exp-022 · the degraded arm, at §12's realistic mix. Same files, same routers, the attribution stanza the only difference. This arm gated too: every prior router reproduces exp-019's realistic-mix level to four decimals.
tier | lnd | hb1 | mx_c3 | deg1 | Δ deg1 − mx_c3
--- | --- | --- | --- | --- | ---
hard test | 0.1880.240 succ · 0.760 give-ups | 0.525 | 0.5170.681 · 0.319 | 0.4980.711 · 0.052 | −0.019p 1.0
out-of-distribution | 0.3340.400 succ · 0.600 give-ups | 0.538 | 0.5640.695 · 0.305 | 0.4880.681 · 0.000 | −0.0761/9 · p .021 · CI excludes zero
split test | 0.7240.792 succ · 0.208 give-ups | 0.808 | 0.8740.958 · 0.042 | 0.7870.917 · 0.000 | −0.0870/8 · p .008 · CI excludes zero
drift test | 0.1590.226 succ · 0.774 give-ups | 0.394 | 0.3900.600 · 0.400 | 0.3790.603 · 0.056 | −0.011p .73
atomic testthe best cell it has | 0.3540.482 succ · 0.518 give-ups | 0.420 | 0.4220.571 · 0.429 | 0.4630.625 · 0.000 | +0.041p .29 · CI straddles zero
mainnet | 0.7090.730 succ · 0.270 give-ups | 0.789 | 0.7860.810 · 0.190 | 0.6790.800 · 0.090 | −0.1080/10 · p .002 · CI excludes zero

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).

exp-022 · degradation flatness. Each cell is degraded minus clean on the composite, so zero is a router the lying channel cannot touch. lnd's two positive cells are not robustness: they are §12's abandonment effect, where the objective rises because lnd stops paying for hard payments.
router | hard | OOD | split | drift | atomic | mainnet
--- | --- | --- | --- | --- | --- | ---
lndsuccess 0.493 → 0.240 on hard | −0.121 | −0.024 | −0.113 | −0.077 | +0.034 | +0.015
hand-written seed | −0.016 | −0.007 | −0.007 | −0.034 | −0.019 | −0.008
hb1 | −0.061 | −0.007 | −0.006 | −0.048 | −0.025 | −0.002
mx_c3champion of record | −0.067 | −0.017 | −0.002 | −0.064 | −0.021 | −0.004
atomic1 | −0.042 | −0.043 | −0.014 | −0.079 | −0.009 | −0.001
deg1bred on the lying channel | −0.011 | −0.001 | −0.001 | −0.013 | +0.000 | +0.000

### 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.

exp-022 · cap sensitivity on atomic test, clean arm — the one tier where deg1 leads. The published objective caps the attempt penalty at fifteen extra attempts, so everything past sixteen attempts a payment is free. Re-scoring the same runs at 30, 60 and no cap changes no router's behaviour; it only changes what the score is allowed to notice.
router | cap 15published | cap 30 | cap 60 | uncapped
--- | --- | --- | --- | ---
lnd | 0.320 | 0.170 | −0.130 | −0.602
hand-written seed | 0.403 | 0.275 | 0.123 | −0.004
hb1cap-insensitive to four decimals | 0.445 | 0.445 | 0.445 | 0.445
mx_c3 | 0.444 | 0.440 | 0.440 | 0.440
atomic1 | 0.403 | 0.396 | 0.396 | 0.396
deg1leads the field, then worst in it | 0.463 | 0.313 | 0.013 | −0.262

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.

#### the plan-time thesis, confirmed a third time

This is the exact inverse of exp-013's give-up attractor: omni1's no-guardrail shape (§13) reached by a different road, from a corpus that rewards persistence rather than from a seed with no attempts left to save. And it is the third independent line of evidence that the champions' edge lives at plan time. §13 found the alternatives could not reach the band on proposal quality; §14 found every bound-reactive amount policy reduces to a descent lnd already runs; and now a search given a genuinely new pressure, and 400 evaluations to answer it, bought robustness with unbounded retrying rather than with better plans. Success-side memory feeding the initial amount choice, and joint route-set construction, remain the things nothing has re-derived cheaply.

### 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.

Caveats. Eight to ten files a tier, as on every sweep here, and 648 of 648 runs completed with zero errors and determinism double-checked. One magnitude result should not be read as a consistency result: deg1 over the seed on split test, +0.144 clean and +0.150 degraded, has an interval excluding zero on a sign test of exactly 4 of 8, so it is carried by half the files. The degradation instrument realises unknown 0.141 to 0.190 and shift 0.052 to 0.077 against the configured 0.2 and 0.1, matching exp-019's realised rates rather than its nominal ones. And the mainnet tier is real topology and real policies with synthetic liquidity, the standing caveat in §00; nothing here changes it.

17

## The world got prices

Everything above this line was measured in an arena that gives away most of the economics of a Lightning payment. exp-023 put a price on five of them — announced HTLC limits, inbound fees, a real fee budget, concurrent payments, latency — each behind its own flag, each proven byte-identical with the flag off, all five specified, built and swept inside a single day. The 1,920-run sweep answers the question the program had been circling from three directions, and the answer is sharper than the question: the champions' edge is informational, not a pricing edge.

2of five mechanisms
close the champion gap, and they are exactly the two that are prices — fee budgets and inbound fees. Announced limits, contention and latency do not move it at all
port the belief system, not the cost model
−0.190gap move, mainnet at 25 ppm
how far hb1's lead over lnd narrows on the mainnet tier once payments carry a fee budget — 10 of 10 files, p = .002, and the same shape at 400 and 100 ppm
the largest single effect anywhere in the sweep
0budget refusals, lnd
at every one of six fee rungs. lnd's fee-aware pathfinding never sends a route it cannot afford; the evolved routers, which cannot see a fee they never priced, are refused 27 to 311 times a file
each refusal is an attempt spent on a route the sender could have priced itself

### 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.

exp-023 · does economic realism close the champion-versus-lnd gap? One row per mechanism, each pre-registering what it should select for so that a null is a finding rather than a disappointment. Ten files a tier, twenty on contention; a directional claim needs the bootstrap interval to exclude zero and the sign test to reach p < .05.
mechanism | gap? | what the sweep measured
--- | --- | ---
A · announced HTLC limitstight and mainnet-empirical rungs | no | Gap moves straddle zero on both rungs, and the tight caps hurt lnd most: −0.104, 9 of 10, p = .021. Free public bounds do not substitute for learned ones.
B · inbound feesheavy, empirical, and the real policies | yes, on the authored rung | Under heavy inbound fees the champions' significant lead over lnd disappears: hb1 +0.194 → +0.041, mx_c3 +0.230 → +0.051, neither significant. On the real mainnet inbound policies, exactly null — ten ties of ten.
C · fee budgetssix rungs across two tier families | yes, and it is the largest | The narrowing clears the full bar unanimously on mainnet: hb1 −0.154 / −0.186 / −0.190 at 400 / 100 / 25 ppm, mx_c3 −0.123 / −0.174 / −0.167.
D · concurrent paymentswindows of 1, 2 and 4, churn held constant | no | Window 4 significantly costs every router — lnd −0.074, hb1 −0.112, mx_c3 −0.077, atomic1 −0.029, all clearing the bar — but it costs them about equally. Every gap move straddles zero at n = 20: underpowered, reported as such rather than as a null.
E · latencysequential and concurrent rungs | no | The null landed in its strongest possible form: with background traffic removed, all five routers are exactly identical under latency alone, lnd included. Objective L never flips a sign.

### 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.

exp-023 · the mainnet fee ladder. Composite objective, with success, attempts per payment and budget refusals per file underneath; the leader of each rung is bold. The control row is the sealed exp-009 mainnet tier, and it reproduces the published numbers exactly, which is what licenses reading the rest of the column.
rung | lnd | seed | hb1 | mx_c3 | atomic1
--- | --- | --- | --- | --- | ---
no budget control the tier every earlier section used | 0.6940.79 succ · 19.8 att | 0.7620.82 succ · 6.1 att | 0.7900.81 succ · 2.3 att | 0.791 0.81 succ · 2.3 att | 0.7900.80 succ · 1.6 att
400 ppmauthored, generous | 0.6270.72 succ · 24.1 att · 0 refused | 0.5880.71 succ · 32.3 att · 277 | 0.5700.68 succ · 16.8 att · 152 | 0.6000.70 succ · 12.1 att · 101 | 0.687 0.72 succ · 4.2 att · 27
100 ppmabout what a real sender sets | 0.5760.68 succ · 24.3 att · 0 refused | 0.5190.64 succ · 54.0 att · 515 | 0.4870.61 succ · 27.3 att · 262 | 0.4990.62 succ · 21.1 att · 198 | 0.607 0.66 succ · 6.3 att · 50
25 ppmauthored, punishing — lnd takes the tier | 0.531 0.63 succ · 25.4 att · 0 refused | 0.4640.60 succ · 65.3 att · 636 | 0.4380.57 succ · 32.0 att · 311 | 0.4610.59 succ · 25.8 att · 247 | 0.5290.60 succ · 8.4 att · 73

### 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.

#### the attempt axis, re-priced

Stage E carried a pre-registered re-scoring arm rather than an objective change: replace the composite's 0.01·min(extra attempts, 15) with a latency penalty calibrated so that the mean cost to mx_c3 is identical, then re-score the archived runs with no re-execution. The motive is §16's finding that the attempt cap is a measured objective weakness, and the deeper worry underneath it: three parallel shards cost one unit of time and three units of attempt penalty, and a nine-hop route and a two-hop route cost the same. Objective L never flips a sign on any tier. So the two results sit together honestly — a capped cost term does create a free direction past the cap, and yet nothing published here changes when the axis is replaced by time.

### 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.

Caveats. Ten files a tier, twenty on contention. The heavy, tight and 25 ppm rungs are authored and labelled as such; the empirical rungs, fitted to the real snapshot, come out close to inert, which is a statement about today's mainnet policy distribution as much as about the routers. The composition tier with all five knobs live is exploratory only — its fee rung was calibrated on the wrong profile and crushes lnd's fees asymmetrically — so no verdict is drawn from it. And the byte-identity proof turned up something older than this sweep: the mainnet tier has never been byte-reproducible, because lnd's own pathfind.go breaks ties by Go map iteration order. The effect is the last digit of an attempt count, the objective gates have held at three decimals through every reproduction, and a simulator-only deterministic sort would change route choices and so move the numbers it exists to protect. Accepted and caveated: mainnet attempt figures carry a small run-to-run component no seed controls.

18

## Evolution learns to count

§17 said the champions' weakness is pricing and left one run to do about it. exp-025 bred a router in the world where money is real. It took two attempts — the first died on a single missing type declaration — and the second produced the first candidate in this program ever to read the fee budget it is handed. It is not a champion. It is the fee-budget specialist, challenger number nine, and it carries the first beat-lnd result on a bar that was actually live.

0budget violations, all six budgeted tiers
econ2 matches lnd exactly, and it is the first evolved router ever to do so. The seed is refused 22 to 644 times a file, hb1 9.9 to 291, mx_c3 9.9 to 220, atomic1 8.6 to 62.5
not a lowered fee weight — a budget threaded through the search
+0.135over lnd on the econ world
interval [0.077, 0.196], 16 files to 3, p = .004 — on the first corpus this program has built where lnd outscores the hand-written seed, so the bar was live rather than decorative
a program first — the held-out split agrees, 16 files to 4, with an interval that straddles zero by 0.002
59of 59 proposals scored zero
in the first run, all on one API confusion: 53 reached for the reflect package to duck-type an imagined Option wrapper, and the sandbox rejected every single one
an accidental live demonstration that the seal works

### 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.

exp-025 · econ2 against the field, 1,524 runs over 21 tiers with the classic gates bit-exact against §17. Composite objective, leader of each tier bold. The fee-budget rungs are where it was bred; the classic tiers underneath are the sealed set every champion was decided on.
tier | lnd | seed | hb1 | mx_c3 | atomic1 | econ2
--- | --- | --- | --- | --- | --- | ---
mainnet, 400 ppmwhere the champions go negative | 0.627 | 0.588 | 0.570 | 0.600 | 0.687 | 0.721
mainnet, 100 ppm10 of 10 against both champions, p = .002 | 0.576 | 0.519 | 0.487 | 0.499 | 0.607 | 0.664
hard profile, 4000 ppm | 0.303 | 0.444 | 0.298 | 0.343 | 0.335 | 0.434
hard profile, 2000 ppmidentical at every attempt cap | 0.136 | 0.172 | 0.167 | 0.192 | 0.141 | 0.259
econ world, held-out testmargin is 56–73% cap subsidy | 0.246 | 0.237 | 0.185 | 0.193 | 0.188 | 0.294
clean mainnetthe tier the champions own | 0.694 | 0.762 | 0.790 | 0.791 | 0.790 | 0.777
hard sealed test | 0.309 | 0.530 | 0.586 | 0.583 | 0.510 | 0.541
drift testecon2's worst tier — below even the seed | 0.236 | 0.414 | 0.442 | 0.454 | 0.299 | 0.283

### 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 frontier is three regimes deep

One evolution run in the priced world produced a router that keeps the informational machinery — interval beliefs, soft evidence — and does the arithmetic, beating lnd where the champions cannot, while giving back ground in the old worlds. That is §16's trade shape again, milder this time, and with cap-robust wins where it was bred. What it leaves behind is a frontier no single router owns: hb1 and mx_c3 where information wins, atomic1 in the flat, atomic and contended niches, econ2 where money is scarce. The hybrid the data keeps pointing at is the same one the lnd branch is building — evolved beliefs on top of lnd's pricing — and econ2 adds a concrete suggestion to it: the pricing side wants budget-aware search, not just budget-aware filtering.

Caveats. Ten files a tier, twenty on contention, as everywhere here. The econ_test cap subsidy is stated above rather than buried. The inbound-fee base defect means the heavy-tier numbers understate what a corrected variant would score, so read them as a floor. And one gate pass was interrupted by the machine's daily /tmp cleaner removing the mainnet graph mid-run at the date rollover — errors are never cached, the re-run filled cleanly, and the graph should live somewhere less ephemeral before the next sweep.

19

## The flag flip pays the champions' margin

Every number above this line was measured under the simulator's own contract, where a candidate owns route selection outright. The interval-router branch does not: it puts the evolved belief system inside lnd's real payment lifecycle, behind a flag, with lnd's pathfinding types, session interface, budget plumbing and MPP machinery all still in charge. exp-027 is the first measurement of that branch. It scores champion-grade, it took six rounds and three falsified hypotheses to get there honestly, and it is the thing we intend to ship.

14of 14 tiers, CI-solid over stock lnd
zero losses anywhere in the final adjudication: classic, degraded and fee-budget families alike, 4 wins to 1 loss against hb1, 3 to 5 against mx_c3, and all three fee rungs owned against the whole field
branch tip 60cce3572, 12 replicates a file, per-file means
0.788mainnet, against lnd's 0.694
the champions' own margin rather than a fraction of it (mx_c3 0.791), with attempts landing at 2.5 a payment where stock lnd spends 19.8 and the champions sit at 2.3
real topology, real policies, one flag inside lnd
0route refusals at the production default
for every arm including mx_c3, which refused hundreds a file on the tight rungs of §17. Real payments always carry a budget: lnd's RPC layer defaults to 5% of the amount
budget discipline separates routers only far below any default

### 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.

exp-027 · the final adjudication at branch tip 60cce3572. Composite objective, leader of each row bold, rows the integrated router leads highlighted. Every one of the fourteen Δ cells against stock lnd has a bootstrap interval excluding zero. The two mainnet control rows are the same tier measured under both families, and repeat by design.
tier | interval-lnd | lnd | mx_c3 | hb1 | Δ vs lnd
--- | --- | --- | --- | --- | ---
hard sealed test | 0.571 | 0.309 | 0.583 | 0.586 | +0.26210/0 · p .002
out-of-distribution | 0.570 | 0.357 | 0.581 | 0.545 | +0.2139/1 · p .021
splitting pressure | 0.874 | 0.837 | 0.876 | 0.814 | +0.0376/2
drift test | 0.443 | 0.236 | 0.454 | 0.442 | +0.2078/0 · p .008
atomic arena | 0.446 | 0.320 | 0.444 | 0.445 | +0.1268/0 · p .008
mainnet snapshot | 0.788 | 0.694 | 0.791 | 0.790 | +0.0958/2
degraded hard, realistic mixunknown 0.2 + shift 0.1 | 0.462 | 0.188 | 0.517 | 0.525 | +0.2749/1 · p .021
degraded hard, unknown 0.3 | 0.528 | 0.162 | 0.519 | 0.557 | +0.3669/1 · p .021
degraded mainnetthe one open belief gap | 0.751 | 0.709 | 0.786 | 0.789 | +0.0426/4
hard, no budgetecon control | 0.610 | 0.329 | 0.574 | 0.567 | +0.2819/0 · p .004
hard, 4000 ppmround 2's worst result | 0.410 | 0.303 | 0.343 | 0.298 | +0.1079/0 · p .004
mainnet, no budgetecon control | 0.788 | 0.694 | 0.791 | 0.790 | +0.0958/2
mainnet, 400 ppm | 0.730 | 0.627 | 0.600 | 0.570 | +0.1037/3
mainnet, 100 ppm | 0.673 | 0.576 | 0.499 | 0.488 | +0.0969/1 · p .021

### 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 methodology corrections, both self-applied

Mainnet cells were never byte-reproducible, on any binary. Four identity cells failed byte-comparison of the merge-base binary against itself: lnd's findPath expands predecessors by iterating a Go map, and exact cost ties on the dense mainnet graph break by map order. A 40-sample self-control shows the merge base as "novel" against its own first group as any new binary is, with mean attempts agreeing to ±0.05. The bit-exact mainnet cells in earlier gate tables on this page were luck-dependent. Those verdicts stand, because none of them rested on mainnet bit-exactness and the paired statistics carried them, but mainnet should be gated statistically from here on. The interval arm is not run-to-run reproducible either, the same class with more search state, hence twelve replicates a file and a recorded noise floor beside every number above.

Algebraic identity is not float identity. A rewrite that is exactly equal on paper moved five tiers, because the frontier compares doubles with ==. A refactor inside a comparison-sensitive search is a behavioural change until measured otherwise.

### 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.

What this branch is for. The program's central bet was that the edge lives in the belief system rather than in the paradigm's ownership of the whole route stack. A flag inside lnd now buys +0.095 objective on real topology, the full §12 robustness story, and the first router in the field that is simultaneously champion-grade on clean tiers and lnd-grade on fee budgets, all with stock lnd untouched when the flag is unset. This branch is the release candidate for the next lnd major release, and every remaining item on the board now points at it.

20

## The give-up attractor is a rule

exp-026 built the world where every pressure is switched on at once, the five economic knobs of §17 plus the lying channel of §16, and 400 evaluations of reflective search returned the seed unchanged. It pre-registered two escapes. exp-028 ran the first one: seed the search from econ2, the specialist that already carries the budget machinery paid for. The machinery transferred. The search on top of it went backwards, in exactly the shape exp-013 registered earlier.

−0.030best candidate against its own seed
on held-out, paired 9 wins to 10 losses and a tie, with every point of it success (−0.031) and every attempt saved (−4.2 a payment) a payment abandoned rather than a payment routed better
give-up rate equals one minus success identically on both arms
+0.022the machinery does transfer
econ2's own composed held-out is 0.2373 against the hand-written seed's 0.2157, so the budget discipline §18 measured in the clean economic world survives the lying channel intact
the wall is search on top of a seed, not the seed
2of 2 seed families, 2 of 2 worlds
the identical failure shape now reproduced from atomic1 in the atomic arena and from econ2 in the compose world, different lineage, different environment, same decomposition
two independent reproductions make it a rule, not an anecdote

### 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.

exp-028 · the composed held-out set, seed against best candidate, paired per file. Read objective and success together: the objective loss and the attempt saving are the same event counted twice.
arm | objective | success | attempts / payment | give-up rate
--- | --- | --- | --- | ---
econ2the seed, 1,230 lines | 0.2373 | 0.3779 | 22.6 | 0.6221
code_full2 best400 evaluations later | 0.2071 | 0.3469 | 18.4 | 0.6531

### 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.

The difficulty ladder, at identical optimizer, budget and seed. Each world adds pressure to the one above it; the last row swaps the seed rather than the world.
world | seed | gain over seed, validation | held-out against the seed
--- | --- | --- | ---
clean | hand-written | +0.05 to +0.06 | ahead
lying channel | hand-written | +0.044 | ahead
economic | hand-written | +0.022 | ahead
compose | hand-written | +0.000seed returned | level
compose | econ2 | best-val below its seed | −0.030

#### what is left of the compose question

One pre-registered escape remains, and it is budget scaling: the same world and the hand-written seed at 800 evaluations, live now as code_full3. With both seed families measured, that arm carries the whole question. If it fails too, the compose world is the first environment where the seed-plus-insights recipe is finished at any seed and any budget, and the interesting frontier moves entirely to the integration branch of §19 and to a liquidity family we did not author. No challenger came out of this run, so the ledger stays where it has been since exp-007: champions hb1 and mx_c3, specialists atomic1 and econ2, nine challengers deep.

21

## The ordering survives on balances nobody fit to

The standing correction at the top of this page says the mainnet tier is real topology and real policies with our liquidity painted over it, drawn from the same generator the evolved priors were fit to. §11 answered half of that with thirteen families the constants had never seen, and every one of the thirteen was still a distribution we chose. exp-029 is the other half: dijkstrasden's revised model graph, 11,255 nodes and 37,203 edges, with per-edge balances generated from ln-scores mission-control data through a fee-conditioned mixture model nobody here touched. It is the first liquidity family in this program that we did not author.

10of 10 files, all six arms, p .002
every evolved router and the integration branch beat stock lnd on every file, with every bootstrap interval excluding zero. Nothing about the ordering needed our generator to hold it up
100 payments a file, n = 10, the mapped exp-009 hub vantage
+0.132against +0.097 on classic mainnet
the paradigm's lead over lnd grew by about a third on the foreign balance sheet rather than shrinking: lnd 0.596, the champions 0.723, atomic1 0.728, with the tier harder for everyone
all of it attempts converted into success and efficiency
+0.009what the swap is worth to the fitted champion
the smallest gain of the seven arms, against +0.025 for the never-fitted hand seed, and not one of the seven intervals excludes zero. The circularity caveat is now a measured quantity, and the quantity is approximately nothing
paired on identical files and topology, only the balances swapped

### 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.

exp-029 · the foreign balance sheet, seven arms, ten files of a hundred payments. Composite objective, leader bold. Every Δ against stock lnd is 10 wins to 0 losses at sign p = .002 with a bootstrap interval excluding zero.
arm | objective | attempts / payment | Δ vs lnd | interval
--- | --- | --- | --- | ---
atomic1the flat-liquidity specialist | 0.728 | 1.9 | +0.132 | [+0.109, +0.151]
mx_c3champion | 0.723 | 2.6 | +0.127 | [+0.102, +0.149]
hb1champion | 0.723 | 2.4 | +0.126 | [+0.104, +0.147]
interval-lndthe release candidate | 0.722 | 2.7 | +0.126 | [+0.102, +0.148]
econ2the fee-budget specialist | 0.713 | 3.8 | +0.116 | [+0.094, +0.137]
hand-written seednever fitted to anything | 0.701 | 5.6 | +0.105 | [+0.081, +0.125]
lnd production stack | 0.596 | 14.9 | baseline | baseline

### 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 family swap, foreign balances minus our own bimodal generator on identical files and topology. Seven arms, seven intervals straddling zero. Ordered by how much each arm gains, which is the opposite of the order an overfit prior would produce.
arm | Δ objective, foreign − ours | interval | fitted to our generator?
--- | --- | --- | ---
hand-written seed | +0.025 | [−0.007, +0.054] | no
econ2 | +0.023 | [−0.004, +0.047] | yes
lnd production stack | +0.020 | [−0.005, +0.041] | no
atomic1 | +0.016 | [−0.010, +0.037] | yes
hb1 | +0.015 | [−0.013, +0.040] | yes
interval-lnd | +0.012 | [−0.010, +0.031] | inherits hb1's priors
mx_c3the most-fitted arm in the field | +0.009 | [−0.018, +0.032] | yes

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.

#### what this result does not cover

One vantage, the mapped exp-009 hub, and n = 10. And the graph is still a model, fit to one prober's mission-control history rather than measured off channel state, so the last circularity is a different party's modelling choice instead of ours. That is a real improvement and it is not the end of the line. The end of the line is replay, on a real node's recorded attempt stream, with no simulator in the loop.

22

## Misattribution manufactures innocence

§19 closed with one thing it could not explain. On the tier where both attribution failures run at once, unreadable errors at 0.2 and shifted blame at 0.1, the integration branch loses 0.034 of objective, while unreadable-only, shifted-only and unreadable-at-0.3 all sit at or above the reference. Two degradations together cost roughly five times the sum of their separate parts. With the branch set as the release candidate, that interaction had to be understood before an upstream reviewer found it. exp-030 found the mechanism, and it is a trust boundary drawn in the wrong place.

9.6%of convictions land on channels that never failed
against 0.0% with unreadable errors alone, counted against the simulator's ground truth rather than inferred. The quarantine convicts the innocent precisely when something else has exonerated the guilty
more promotions than the harsher unreadable-only tier, on fewer unreadable failures
+0.0439the committed fix on the mixed tier
0.4698 on the broken tip to 0.5138, which is not a recovery to the pre-quarantine reference of 0.5039 but a pass through it, with the clean tier unchanged to four decimals
one field wide: only a settlement proves innocence
3suppression rules, one false bound
the suspect-list filter, the early return in suspect recording, and the contradiction clearing in normalization are all keyed on the same lower bound, so one fabricated bound disarms the whole quarantine at once
ablation: disable the quarantine and the mixed tier recovers +0.0355

### 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

exp-030 · the fix ladder, each variant against the branch tip on the five mechanism tiers. The mixed tier is the one the fix is for; the other three columns are what it costs elsewhere. Leader of each column bold.
variant | mixed tier | unreadable 0.2 | unreadable 0.3 | clean control
--- | --- | --- | --- | ---
V3 · only a settlement proves innocence | +0.0406 | −0.0073 | −0.0092 | −0.000009
V1 · no quarantine at all | +0.0355 | −0.0050 | −0.0063 | +0.0000
V2 · no bounds from probes | +0.0283 | −0.0593 | −0.0854 | −0.0005
V4 · require corroboration | +0.0212 | −0.0452 | −0.0454 | −0.0000

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 five mechanism tiers, from the reference the loss was measured against, through the broken branch tip, to the committed fix. The mixed tier is the whole story; the rest are the controls that have to stay still.
tier | reference | broken tip | V3 throwaway | committed fix
--- | --- | --- | --- | ---
clean control | 0.5715 | 0.5715 | 0.5715 | 0.5715
unreadable 0.2 | 0.5719 | 0.5747 | 0.5674 | 0.5694
shifted 0.1 | 0.5266 | 0.5230 | 0.5248 | 0.5255
mixedunreadable 0.2 + shifted 0.1 | 0.5039 | 0.4698 | 0.5105 | 0.5138
unreadable 0.3 | 0.5271 | 0.5351 | 0.5259 | 0.5264

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 magnitude is not as well pinned as the mechanism

The mechanism is established three ways: an ablation that moves the tier and nothing else, ground-truth counters that read the simulator's record of which channel actually failed, and a replicate z of −11.1 on the original loss. The size of all of it rests on one ten-file degraded corpus with large between-file variance, and at that n the paired bootstrap straddles zero for every variant, including for the original loss. A wider degraded corpus should re-pin these numbers before an upstream pull request quotes them, and that re-pin is the one item still open on this record.

23

## The compose world is closed

§20 left the compose question on one arm: the same world and the same hand-written seed at double the budget. It ran overnight, and the wall did not move. 800 evaluations returned the seed to seven digits, which closes both pre-registered escapes and, with them, the evolution track's search for new machinery in this environment.

0.3162367best validation, which is the seed's own gate number
and held-out test 0.21568, equal to the seed's digit for digit. Not a marginal loss and not a noisy tie: the optimizer handed back the thing it was given
698 of 800 evaluations consumed, against 385 in the 400-eval arm
19pool accepts, none of which survived
60 proposals, zero hijacked reflections, and nineteen candidates accepted on subsample wins where the 400-eval run managed eight. Every one of them fell below the seed on the full validation set
a generous, healthy run, not a starved one
2of 2 pre-registered escapes failed
the specialist seed went backwards by 0.030 (§20) and 1.8× the search went nowhere. The ladder ends at zero and stays there under both perturbations
identical corpus, prompt, optimizer and gate throughout

### 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.

The difficulty ladder at close. The first four rows move the world at a fixed seed and budget; the last two perturb the seed and the budget at the fixed world, which is what the compose row's two pre-registered escapes were.
world | seed | budget | gain over seed | outcome
--- | --- | --- | --- | ---
clean | hand-written | 400 | +0.05 to +0.06 | champions
lying channel | hand-written | 400 | +0.044 | the most degradation-robust router measured
economic | hand-written | 400 | +0.022 | the fee-budget specialist
compose | hand-written | 400 | +0.000 | the seed, returned (exp-026)
compose | econ2escape one | 400 | −0.030 held out | the give-up attractor (exp-028)
compose | hand-writtenescape two | 800 | +0.000 | the seed, returned to seven digits

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).

Evolution found the paradigm; engineering is shipping it. No challenger came out of this run, so the ledger closes where it has stood since exp-007: champions hb1 and mx_c3, specialists atomic1 and econ2, nine challengers deep. The tree is free, no run holds the router, and the value has moved to the release candidate and to offline replay on a real node's payment history. Breeding resumes when a new world reopens the space, and there are two candidates for it already: the foreign graph as a training corpus rather than a test tier, and scenarios derived from replay.

24

## What the process taught us

Findings about running this kind of search, which cost as much to learn as the routing results did.

### 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.

25

## Timeline of experiments

Thirty-two writeups, eight days of wall-clock time, in numbered order. Full detail lives in simulation/lab/experiments/.

exp-001
Parameter smoke run
Sixty evaluations bought seven proposals and accepted none. Diagnosed two harness bugs rather than an algorithmic result: the eval budget was starved, and unbounded attempt penalties drove per-example scores to −2, drowning the success signal. Penalties now saturate at −0.25.
negative · fixed
exp-002
Full parameter run — the defaults survive
400 evaluations, 33 iterations, 16 proposals over estimator choice, attempt cost and minimum probability. Best on validation: the lnd defaults, 0.3647; sealed test 0.3430. No knob change beat them.
the pivot
exp-002b
The knob we never turned
lnd's own bimodal estimator, run at seven scales including the one this environment calls for — 5% of a typical channel, the constant our generator actually uses. No scale beats lnd's shipping apriori default (hard: best bimodal 0.283 against 0.298), and the matched scale is among the worse settings. The mechanism is the finding: a better prior raises success and more than doubles attempts, because it changes which route lnd retries and never how much it sends (§09).
the knob, turned
exp-003
A naive router beats the production stack
The ~300-line seed wins or ties 16 of 16 examples against full lnd pathfinding: 1.9× the success rate at 2.3× fewer attempts, and 0.547 against 0.393 on the corpus-v2 objective. Near parity on scale-free graphs, far ahead on bimodal small-channel ones.
paradigm > knobs
exp-004
Code-mode evolution opens
GEPA starts rewriting whole algorithms. Four iterations in, a candidate accepts a 967-line rewrite that invents per-channel liquidity knowledge — lower and upper bounds with a confidence score — and cuts attempts per payment from 26 to 9.
first structure
exp-005
Adversarial audit of the simulator
BOLT forwarding math checked out; the sandbox did not. One critical escape found and sealed the same day, with zero candidates having used it. Three contract-affecting fidelity fixes batched for later, including a deterministic clock for mission control.
integrity
exp-006
Breakthrough — hb1 beats lnd and the seed
An 872-line evolved router wins the sealed hard test (0.586) and generalizes out of distribution (0.545), at roughly 9 attempts per payment against lnd's 50. It got there from failure traces alone: bimodal prior, per-edge liquidity bounds, risk-adjusted Dijkstra. Reruns are bit-identical; no exploit.
champion · hb1
exp-007
Continuing from the champion — mx_c3
Seeded from hb1 on a mixed corpus. Twelve straight rejections, then four Pareto siblings; the last, mx_c3 at 1,525 lines, ties hb1 on the hard test, wins out of distribution and takes the best combined average. It adds an adaptive retry-at-lower-amount policy. hb2 is superseded.
champion · mx_c3
exp-008
Background traffic and a virtual clock
Built and opened after exp-011, once it was clear that more budget in a static world bought nothing. Exogenous senders move hidden liquidity between our payments and lnd's decay finally runs on a real clock. The champions' hard bounds survived drift, lnd's decay did not close the gap, and then code_drift1 answered the question it was built for: time-awareness re-evolved — a 35-minute confidence half-life, hard bounds expiring at twenty — and still lost every tier, drift included. Full verdict in the drift chapter.
verdict · drift1
exp-009
Mainnet-graph validation
12,161 nodes, 39,659 channels, 100 payments. The champions match lnd's success rate at 8.6× fewer attempts — 2.3 against 19.8 — on the graph lnd's defaults were tuned for and the champions had never seen. Objective 0.791 against 0.694. (The ratio stood for eleven experiments and was retired by exp-019; the objective and success numbers are untouched.)
closing validation
exp-010
Splitting pressure — joint planning, three times over
A corridors corpus of unequal parallel tiers, where the fattest tier caps any single shard and a forced max_parts = 1 control fails every file. Three proposer lineages ran it on the same budget and seed, and all three evolved joint route-set planning: one-step lookahead, up-front corridor-sized shard sets, and persistent parallel flow plans at 1,931 lines. The Opus-default arm posted the program's first statistical tie with a champion on any tier, then collapsed off-corpus. Champions unchanged (§06).
verdict · three arms
exp-010b
Atomic commitment — the arena stops subsidising probes
Shards hold liquidity until the whole payment settles, siblings contend for what is held, and traffic drifts on every attempt boundary, with flag-off byte-identity preserving every earlier result. The baseline reordered before evolution ran: lnd fell from second to last at 105 attempts per payment. Two arms then re-evolved up-front reservation planning, and the codex winner became the first challenger with no collapse tier — 1.6 attempts per payment on mainnet, the lowest ever measured here — while still finishing −0.044 short on the home tier. Champions unchanged (§07).
verdict · fifth hold
exp-011
The paradigm ceiling
A third lineage, seeded from the small original router with the champions' insights given as four sentences of prose, reached champion class in 400 evaluations — 0.638 combined against 0.640 and 0.652 — and passed neither. It also invented two mechanisms the simulator does not reward. Insight transfer works; the design is at a local optimum for static environments (§05).
ceiling · gen2
exp-012
Cold cache against hot
Four arms on the question a served weight cache actually poses. lnd's mission control does not warm inside a ten-payment batch — its disadvantage grows 4.7× to 11.9× — while the champions are already cheap on payment one, so their edge is a prior and not a history. Under a maximally stale cache the field splits three ways: lnd thrashes, both champions abandon, and atomic1's 0.012 probability floor shrugs, beating mx_c3 by +0.428 at p = 0.002 — the program's first significant win over a champion. The staleness-gap null then indicted our own churn engine, only 18% of whose payments settle. Champions unchanged (§08).
verdict · floor, not zero
exp-013
The give-up attractor
The recipe that turned hb1 into mx_c3, applied to atomic1, produced a router that lost to its own seed on the run's held-out test, 0.512 against 0.527, and sat below mx_c3 on all six tiers. The attempt column explains it: fewest attempts everywhere and lowest success everywhere, converging on split_test to 2.2 attempts and 0.750 success where every other router exceeds 0.917. It did not get more efficient, it stopped trying. A seed already at the attempt frontier leaves abandonment as the only cheap direction left.
negative · a hazard named
exp-014
The traffic engine was five times weaker than configured
A failed background payment moves no liquidity, so the settle rate is the factor between the churn a scenario asks for and the churn it gets: 0.41 on drift, 0.61 on atomic, 0.18 on mainnet. The two obvious fixes — route on hidden balances, shrink amounts until they fit — moved mainnet from 0.177 to 0.184. The actual defect was uniform endpoint sampling on a graph whose median degree is one, where 68% of nodes hold two channels or fewer, so most drawn pairs had no path at any amount. Degree-weighted sampling moved it to 0.951. Every published ordering survived the fix.
infrastructure · nothing overturned
exp-015
exp-008 called a tie a loss
drift1 against the champions on one fixed corpus with only the churn rate varying, up to roughly eighteen times what exp-008 actually ran under: −0.016, −0.005, −0.007, −0.003. A tie at every level including none. The original had compared two point estimates at n=8 with no paired test. This mattered beyond the record, because the harness prompt had been telling every candidate that decay LOST and to spend its complexity elsewhere — an unsupported negative acting as a search restriction we had imposed on ourselves. The prompt now states the tie and leaves the question open.
correction · our own claim
exp-016
Free knowledge helps the champions and hurts lnd
A third-party node's observations injected from a file with no payment sent — the arm exp-012 could never build. atomic1 gains +0.055 and mx_c3 +0.031 with attempts nearly halved, while lnd loses 0.029 and its attempts rise. Splitting the stream locates the cause: successes help everyone, and failures are the entirety of lnd's loss at −0.039, worse on 9 of 10 files. An interval router turns an imported bound into a smaller shard to try; lnd can only delete the route, because nothing downstream of its estimator can resize a payment. The mechanism took three wrong guesses to find, and the first was published before it was checked (§10).
verdict · serve observations
exp-017 · build
The liquidity generator becomes a parameter
AssignLiquidity learns families — bimodal at any scale, beta with polynomial rather than exponential tails, and a hubdrain that points the depleted end at the higher-degree node — with the legacy strings golden-tested byte-identical so no earlier corpus moves. Two generators then emit paired corpora: ten base scenarios written once, one directory per family differing in a single field, and the exp-009 mainnet tier re-liquified by one-line substitution under a parse-and-compare assertion. The mainnet tier itself is checked into the repo for the first time.
instrument
exp-017
The paradigm survives generators it was never fit to
Thirteen paired tiers × five routers = 650 runs, moving the liquidity family, the amount family and the mainnet balances out from under everyone. lnd finishes fifth of five on 13 of 13 and an evolved router first on 13 of 13, with the mainnet control reproducing the published exp-009 numbers to three decimals. Margins compress on the flatter worlds, but the never-fitted seed compresses with the same shape, so the compression is a difficulty ceiling and not memorised constants. Two reorderings fall out: atomic1 is a flat-liquidity specialist, rank 4 → 1 monotone along the ladder, and mx_c3 is at or below hb1 on 12 of 13 tiers, which put its “generalist” title into adjudication — resolved the same day by exp-020 in mx_c3's favour. Champions unchanged (§11).
verdict · de-circularised
exp-019 · build
The attribution degrader
An attribution section on the scenario file corrupts results at the single ReportAttempt delivery point both consumer paths share, so lnd and every candidate face the identical stream: unknown_prob strips source and code, shift_prob blames an adjacent hop with the code intact, and delay_slices holds results back through background-traffic time. The unknown path converts to the nil failure message the switch really hands mission control on ErrUnreadableFailureMessage, so lnd runs its own processPaymentOutcomeUnknown rather than an imitation of it. Three uniforms are drawn per attempt whatever the outcome, and with the section absent the binary is byte-identical to the pre-change one.
instrument
exp-019
Degraded attribution — the 8.6× dies, the margin survives
Six levels on the sealed hard tier, the realistic mix on mainnet, delay isolated on drift: 520 paired runs whose controls reproduce exp-020 to three decimals. The ordering survives everywhere, and hard-tier margins widen under unreadable errors, because no evolved router writes a bound from an unattributed failure. lnd does the opposite — processPaymentOutcomeUnknown penalizes the whole route both ways, so 10% unreadable errors drive give-ups 0.31 → 0.71 and 30% pins files to zero success. Delay is free for everyone; misattribution is the binding constraint. One anomaly ships labelled as one: shift = 0.3 helps lnd, +0.122 at p = .002, mechanism unproven. And the headline ratio is retired — under degradation lnd uses fewer attempts than the champions because it stops paying for hard payments, while the champions hold mainnet success at exactly their undegraded values and lnd loses six points (§12).
verdict · the ratio retired
exp-020
The championship adjudication: mx_c3 defends
The original tier set, the exp-017 binaries, paired per file, with the mainnet, hard and OOD gates reproducing the published numbers to three decimals. hb1 significantly beats mx_c3 nowhere; mx_c3 beats hb1 on split-test alone, unanimously — +0.062, 8 of 8, p = .008 — the one tier where hb1 cannot even beat lnd. Two significant hb1 signals (exp-015, exp-017) turn out to be family-specific and do not transfer: the champion rule is the only reason the record said “in adjudication” yesterday instead of something now known to be wrong. The sweep’s corpus archaeology also found the sealed hard tier silently overwritten in scratch and the hard/OOD tiers unregenerable from any committed generator — both are now checked into the repo verbatim.
verdict · title defended
exp-018
The omni adjudication — the band is not a gepa artifact
Three engines, one seed, one corpus, 150 evaluations enforced centrally. gepa alone produced a router: thirteen iterations and a 947-line candidate at 0.556 held out. meta_harness benchmarks every proposal against the full example set at 68 evaluations a time, so the budget bought it one iteration and it returned its own seed byte-identical; autoresearch burned its allowance in thirteen minutes and returned the seed modulo comments. The moat is eval efficiency, not proposal quality. At practical budgets the ~0.64 band is therefore not an artifact of one optimizer — whether it is a true ceiling needs meta_harness at ten times the evals, now specified and costed at about $2 a swing. The candidate omni1 is challenger failure number six: no collapse tier, but the inverse of the give-up attractor, the most attempt-expensive evolved router on every tier because it evolved no attempt, hop or search caps. Champions unchanged (§13).
verdict · the band holds
exp-021 · build
The distillation patch
Two mechanisms distilled out of the champions and written into lnd's own stack, each behind its own flag: soft_unknown replaces processPaymentOutcomeUnknown's whole-route both-directions penalty with a single minimum-probability pair, and adaptive_split teaches RequestRoute to choose an amount from capped pathfinding probes. The second went through three revisions — supremum search, geometric backoff, expected-value ladder — each killed at the smoke gate by its own trace before a sweep spent real compute. Both flags off, the binary is byte-identical to stock, and the stock arm reproduces the cached exp-019 ladder bit-for-bit.
instrument
exp-021
One fix lands, one theory dies
soft_unknown recovers 86–148% of exp-019's collapse on the hard and drift ladders — success 0.193 → 0.507 at unknown .3, give-ups 0.807 → 0.437 — with success up and give-ups down on every non-tied file, exact-identical behaviour on the clean controls, and a cost stated plainly: it buys that success with 18 to 29 more attempts per payment, which the objective's cap cannot see. It takes back about half the champions' degraded-tier margin and erases atomic1's. adaptive_split is a genuine null: all three designs reduce by their own trace arithmetic to geometric descent from the failure bound, which lnd's blind halving already runs at the fastest ratio, free. The one flattering interim number was pure abandonment and was retracted within the cycle. With exp-002b that closes both halves of the reactive distillation theory and prices the champions' remaining edge as plan-time architecture (§14).
verdict · the fix and the null
exp-022
Breeding under a lying channel
The first evolution run bred with the lie present: the sealed corpus mix with exp-019's realistic attribution mix stamped on train and validation and the test split left truthful. It produced the program's first attribution-confidence machinery — quarantined suspect bounds, payment-local penalties for unreadable failures, an escalation threshold at four unknowns — none of which it was shown an implementation of. The 648-run sweep then said no on both arms: zero tier-conditions where deg1 beats a champion with an interval clearing zero, four where it loses to mx_c3, and on mainnet the first evolved router in this program to land below production lnd, 0.679 against 0.694. What it did achieve is real and measured — the flattest degradation profile ever recorded here, −0.013 to +0.000 across six tiers, against champions losing up to 0.067 — and the mechanism is the finding: 26 to 92 attempts a payment, past the objective's cap everywhere, failing by hitting the harness ceiling rather than by giving up. It breaks the give-up identity, and re-scoring at higher caps inverts its one lead while the champions do not move. Champions unchanged (§16).
verdict · robustness on credit
exp-023 · spec
Economic realism, five flag-gated stages
A design document, not a result. Five mechanisms that put a price on things the arena currently gives away — min and max HTLC pressure, inbound fees, fees as a first-class cost, concurrent payments, latency — each pre-registering what it should select for so that a null is a finding. They land as five separate flags rather than one release, since five simultaneous flags make the flag-off byte-identity proof a product instead of a sum. Stage A is in implementation.
spec · not yet run
exp-024
The ceiling arm — ten times the budget, a lower shelf
The run exp-018 said would separate a problem ceiling from an optimizer that stalls at the starting line. meta_harness on the same seed and corpus at 1,496 evaluations iterated eight times, found five new bests, and produced a real 422-line candidate — the first improvement over the seed any claude-proposer engine has managed here. The trajectory is the finding: +0.0136 in the first three iterations, +0.0002 from the remaining 950 evaluations. That is convergence, not starvation, and the shelf it converges to, 0.514 held out, sits below gepa's own 0.557 at one tenth the budget. The band survives a second engine given real room, so the remaining escape hatches are environment changes rather than optimizer changes. The candidate is challenger failure number seven, and at 0.514 against a seed of 0.508 it earns no tier sweep. Costing held to 3% of the exp-018 estimate (§15).
verdict · not starvation
exp-023 · build
Five mechanisms, five flags, one day
The spec became the arena in a single day, one stage at a time, each landing with a note recording what implementation taught the design. Announced min and max HTLC, with an empirical family fitted to all 62,798 directed policies of the snapshot; inbound fees, including the 4,783 real policies the loader used to throw away; a fee budget the sender is told about and the runner enforces at dispatch; concurrent payments on a deterministic virtual-time event loop that reduces to the sequential batch exactly; and latency priced as an overhead plus a round trip to the hop that resolved the attempt. Every flag proved byte-identical off against a pre-change binary, and the objective was left alone on purpose — the pressure went into the environment, not into the weight.
instrument
exp-023
The economic-realism verdict: the edge is informational
1,920 runs, zero errors, gates reproducing the previous table on 24 of 24 cells to the bit, and every knobbed tier made to prove its engagement counters nonzero before its results counted. Economic realism closes the champion gap on exactly the two mechanisms that are prices and on none of the three that are not. Fee budgets are the largest effect in the sweep — hb1's mainnet lead narrows by 0.154, 0.186 and 0.190 at 400, 100 and 25 ppm, unanimously, and at 25 ppm lnd takes the tier back outright, the only place in the program where the production stack wins one. Heavy inbound fees erase the champions' significant lead; the real mainnet inbound policies are exactly null, ten ties of ten. Announced limits, contention and latency move the gap not at all, with the latency null in its strongest form: five routers exactly identical when latency is the only thing that changed. The source audit found atomic1's fee robustness is a units choice — it prices paths in millisatoshis where the champions price in nats — and stage C found that two fifths of the fees these tiers pay had never been counted (§17).
verdict · port the beliefs, not the cost model
exp-025 · run one
Fifty-nine proposals, one missing type
The first economic-world run scored zero on all fifty-nine of its proposals, every one of them on the same confusion: the prompt described the inbound-fee semantics without naming the Go type, so fifty-three proposals reached for the reflect package to duck-type an Option wrapper that does not exist and six guessed UnwrapOr on a plain struct. The sandbox rejected the reflective ones without exception, which is the cleanest live demonstration of that seal the program has had. Eight prompt lines fixed it, and the lesson goes in the permanent collection: describe data without its type and a code-writing model invents an API.
postmortem · prompt fix
exp-025
The fee-budget specialist — and the first live bar cleared
The relaunch, 382 evaluations, nine accepted candidates, and a 1,230-line winner that is the first router in this program ever to read spec.FeeLimitMsat or price an inbound fee. It did not get there by re-weighting: a remaining-budget ledger, per-shard allocation that decrements as shards commit, fee-cap pruning inside the Dijkstra, a budget-derived exchange rate, and a Pareto label set that never evicts its cheapest path. The 1,524-run sweep files it as the fee-budget specialist and challenger number nine — CI-solid over both champions on the fee rungs and cap-robust there, zero budget violations on every budgeted tier where every other evolved router violates constantly, but a loser on the classic sealed set and worst of all on drift, below even the seed, because the world it grew up in barely drifted. It also clears the program's first live beat-lnd bar, on the first corpus where lnd outscored the hand-written seed: +0.135 on validation, +0.048 held out, and an lnd-beating lead restored on exactly the mainnet fee rungs where exp-023 watched the champions go negative. Champions unchanged; the frontier is now three regimes deep (§18).
verdict · specialist number two
exp-027
The flag flip pays the champions' margin
The first measurement of the integration branch, inside lnd's own payment lifecycle rather than under the simulator's contract. Fourteen tiers, six arms, 804 runs, gates at 104 of 104 byte-identical with the flag off and 24 of 24 against the economic table. The port keeps the paradigm: 0.788 on mainnet against stock lnd's 0.694 and mx_c3's 0.791, attempts at 2.5 against 19.8, the champions' own margin on all six classic tiers rather than a fraction of it. Getting there honestly took six rounds and three falsified hypotheses, the last of which uncovered the bug: budgetedness was inferred from the remaining fee limit, which is never the unbudgeted sentinel after the first shard, so every unbudgeted payment that split was misclassified. Latching the classification at session construction returns ten of eleven unbudgeted tiers to their earlier values and lands the final adjudication at fourteen of fourteen tiers interval-solid over stock lnd with zero losses. The production-default battery is the upstream answer: a real node always carries a fee budget, the margins hold on all six classic tiers under exactly that default, and nobody refuses a route (§19).
verdict · release candidate
exp-028
The give-up attractor, reproduced from a second seed
exp-026 had run the compose world, every economic knob plus the lying channel at once, and 400 evaluations returned the seed unchanged at +0.000. This is the first of its two pre-registered escapes: seed the search from econ2 instead, the specialist that already carries the budget machinery. The machinery transferred for free, econ2 scoring 0.2373 on the composed held-out against the hand seed's 0.2157, so budget discipline is worth the same +0.022 with the lying channel switched on. Search on top of it went backwards: the best-validation candidate lost 0.030 to its own seed on held-out, all of it success, bought with 4.2 fewer attempts a payment. That is exp-013's decomposition with the lineage and the world both swapped, which promotes the give-up attractor from anecdote to rule. No challenger came out of it, and the 800-evaluation arm now carries the whole compose question (§20).
verdict · the rule holds
exp-029
The foreign balance sheet, and the caveat measured to zero
The first liquidity family in this program that we did not author: dijkstrasden's model graph, 11,255 nodes and 37,203 edges, with per-edge balances generated from ln-scores mission-control data through a fee-conditioned mixture model. Seven arms, ten files, the mapped exp-009 hub vantage, and a replicate protocol that caught 53 of 200 cells being nondeterministic after a three-sample screen had called the tier clean. Every evolved router and the integration branch beat stock lnd on all ten files at sign p = .002, and the lead is a third wider than on the tier whose balances we drew ourselves: lnd 0.596 against the champions' 0.723, atomic1 first at 0.728 on the flattest realistic family we have scored, which is the flat-liquidity filing of §11 predicting an ordering on data it had never seen. The paired family swap is the verdict: seven arms, seven intervals straddling zero, the fitted champion gaining least and the never-fitted seed most. The release candidate tracks the champions to the third decimal and gains under the production-default fee limit while paying 267 fewer ppm. The signal the graph was built around is live and unread by everybody, Spearman −0.149 across 74,406 directed ends (§21).
verdict · the circularity caveat is worth ~0
exp-030
Misattribution manufactures innocence
The one unexplained interaction on the release candidate's record, run to ground in a day. A named failure writes hard lower bounds on every hop before the reported index; a shifted report names the wrong hop; so the guilty channel collects a bound certifying it can carry the amount it just refused, walks off the suspect list through all three of the quarantine's lower-bound-keyed suppression rules, and leaves its share of a fixed 1/√n suspicion concentrated on the innocent. One conviction in ten on the mixed tier lands on a channel that never failed, against zero with unreadable errors alone, counted against the simulator's ground truth. The fix is a trust boundary one field wide: only a settlement proves innocence. Four variants measured, the principled one also the best, and the committed implementation re-benched rather than assumed equal to the throwaway. The mixed tier goes 0.4698 to 0.5138, past the pre-quarantine reference rather than back to it, with the clean tier unchanged to four decimals and the innocent-conviction rate landing on the shifted-only floor. The quarantine keeps its place; the magnitude waits on a wider corpus (§22).
mechanism · fix shipped to the RC
exp-031
The compose world is closed
The second and last pre-registered escape from the compose wall: identical corpus, prompt, optimizer and hand seed at 800 evaluations instead of 400. The run was healthy and generous, 60 proposals, zero hijacks, nineteen pool accepts against the earlier run's eight, 698 evaluations consumed for roughly 1.8× the search, and every accepted candidate fell below the seed on the full validation set. Best validation came back 0.3162367, the seed's own gate number, and held-out test equal to the seed's digit for digit. With exp-028's specialist seed having gone backwards, the ladder ends monotone at zero and stays there under both perturbations, which promotes the reading from suspicion to conclusion: the seed-plus-insights recipe is finished in this world at any seed and any practical budget. The pattern it exposes is that every mechanism the frontier owns was bred under exactly one pressure, and no run ever built machinery under two at once. The value sits with the hand-assembled integration branch and with replay (§23).
verdict · the evolution track's boundary
read next
Drift: the environment strikes back

The simulator now has a clock, and other people's payments move liquidity while we are idle. A router bred in that world invented decay on its own — 35 minutes of confidence, twenty of hard bounds — and lost to the champions anyway. Or go back to the overview for the method, the corpus and run telemetry.