In this commit, we record the pre-evolution baseline on the corridors
corpus, and it already contains a finding: this is the first
environment where lnd's production stack beats members of the evolved
lineage. Its divide-and-conquer MPP completes 96% of the held-out
payments -- second-best objective despite burning 23 attempts per
payment -- while the naive seed manages 75% and even gen2 trails it.
mx_c3's evidence-derived shard ladder still leads at 0.876, but at
ten attempts per payment there is clear headroom for a router that
plans its route set up front instead of discovering shard sizes by
failure. The code_split1 run now chases exactly that, with the
reflection prompt naming joint route-set planning as the unexplored
axis.
In this commit, we add the exp-010 environment: a corridors topology
that makes splitting mandatory and makes the right split unequal. K
parallel corridors run from a single source to a single target, each
terminating in one tier channel into the target, and the target has
no other channels -- so the fattest tier is a hard structural ceiling
on any single shard and the sum of tiers a hard ceiling on the whole
payment, independent of liquidity luck. The tier ladder puts one
uniquely fat corridor above repeating rungs each at most half its
size, which is what punishes blind halving: half of an above-tier
payment fits only the fat corridor, so a divide-and-conquer splitter
must keep halving while a deliberate splitter sizes shards to tiers.
Interior hops are 128x fatter than the tiers so the tier stays the
binding constraint, a low-capacity filler cloud tempts fee-greedy
routers without being able to carry a real shard, and corridor fees
rise with tier so cheapest-first search pulls toward corridors that
cannot carry the payment.
The corpus generator gains --split: corridors networks under bimodal
liquidity with no drift, two cheap probe payments that seed corridor
knowledge, then one ambitious payment above the fattest tier, sized
against a measured usable-capacity budget so files discriminate
rather than saturate. End-to-end the corpus already separates
strategies sharply: lnd's production halving completes 75% of the
ambitious payments while the seed's naive halving completes 38%, a
role reversal against every other corpus, and a forced max_parts=1
control fails 40 of 40 files, confirming the structural guarantee.
Determinism, structure, and behavioral tests cover the generator.
In this commit, we update the code-mode reflection prompt for the
splitting-pressure run: the insights section now carries the exp-008
lesson that time-decay of evidence lost to plain hard bounds under
genuine drift, and names joint route-set planning -- choosing a set
of routes and their shard amounts together, min-cost-flow style -- as
the least explored region of the design space, since every winner so
far splits reactively.
We also log the exp-012 design in the ideas backlog: roasbeef's
observation that a new lnd node with no mission control weights burns
a long warmup on an unbalanced network, and the proposed hot-load API
for served weights. The measured warmup curves already reframe the
question -- mx_c3 needs 1.9 attempts on its first-ever mainnet
payment while lnd still burns 40+ attempts on hard payments late in a
batch, so the champions' prior does most of the work a served cache
would -- and the designed experiment covers the unscored warmup
phase, the staleness axis under drift, and the observation that
per-directed-channel bounds are shareable across nodes in a way
mission control's vantage-dependent history is not.
In this commit, we fold the exp-008 outcome into the site. The drift
page's outcome ledger, written before the run, is resolved honestly:
the realized result is the first row's mechanism in the second row's
shape with the third row's verdict, and each row now carries its
resolution inline. A new verdict section presents the evolved clock --
the 35 minute confidence half-life, the 20 minute bound expiry, and
the interpolation back to the prior -- alongside two new figures: a
decay curve contrasting drift1's confidence fade with lnd's one hour
penalty weight, and the six-router drift-test comparison on the same
axis scale as the baseline figure so the two read together. The
four-tier results table and the drift1-versus-gen2 cut carry the
argument, and the closing section separates what the experiment
settles from what it cannot.
The index and findings pages get the matching surgical flips: status
lines move from in-flight to verdict-in, the evidence claim grows to
four of four tiers, and the hand-off now points at exp-010 and the
code_split1 run. Published as Litbucket version 42.
In this commit, we give the code_drift1 winner the same documentation
treatment as the champions: a companion markdown next to its archived
source that walks the time machinery -- the 35 minute confidence
half-life, the 20 minute bound expiry, and the confidence-weighted
interpolation that slides aging evidence back toward the bimodal
prior -- and contrasts it axis by axis with lnd's decay, which fades a
failure judgment toward the apriori estimate rather than fading trust
in evidence toward a learned prior. The doc is honest about why the
router is not promoted: it loses every held-out tier, including the
drift corpus it was bred on, and its own code carries the flaws of a
400 eval budget.
We also flip the champions documentation from pending to resolved.
The README's leading caveat no longer says exp-008 is testing whether
zero-time-logic is a simulator artifact; it reports that the test ran,
that time awareness re-evolved unprompted, and that it lost on every
tier, making the champions' timelessness a validated design property
at this churn rather than an open question. The results tables gain
the drift tier and the drift1 comparison column, the lineage diagram
gains its fourth branch, and the per-champion docs get the same
surgical pending-to-verdict edits.
In this commit, we record the verdict of the drift experiment, and it
answers both halves of the question cleanly while pointing them in
opposite directions. Time-awareness did re-evolve: the code_drift1
winner is the first evolved router with time-based logic, stamping
every liquidity belief, decaying its confidence on a 35 minute
half-life, expiring hard bounds outright after 20 minutes, and
interpolating between learned beliefs and the bimodal prior by that
confidence -- evidence softening with age, structurally unlike lnd's
penalty fading. Selection pressure produced exactly the mechanism the
experiment was designed to test for.
And yet it does not win. On the drift corpus itself the time-aware
winner scores 0.417 against the time-less champions' 0.455 and 0.457
-- and most damning, against gen2's 0.456, a router with the same
budget and seed style that never saw drift during evolution. lnd's
rationale for decay is validated; its necessity is not. At realistic
churn, hard evidence bounds degrade gracefully enough that a stale
bound costs one retry, which is cheaper than the information the
decay machinery throws away. Champions of record remain hb1 and
mx_c3, now validated on a fourth held-out tier.
We archive the winner's source beside the writeup and update the
notebook and CLAUDE.md accordingly.
In this commit, we pick up the dashboard refresh for the code_drift1
run: the exported lineage data now reflects 167/400 evals, best score
0.9209, with the budget still open.
In this commit, we fold the two newest findings into the site without
touching the approved design. The settled result, exp-011's paradigm
ceiling, becomes a new findings section: three independent lineages
converge within 0.014 objective of one another on the same
interval-belief design, shown as a dot plot against the lnd and seed
baselines, with the two unrewarded inventions and the honest limits
(three samples, shared reflection-model culture) called out alongside.
The in-flight experiment gets its own page instead: drift.html, a
third nav tab covering the virtual clock and background traffic
mechanics, the pre-evolution baseline in which the champions' hard
bounds survive drift while lnd's decay still trails, and a ledger of
what each possible outcome of the live code_drift1 run would mean.
Keeping a verdictless experiment out of the findings page preserves
that page's register, and the new tab gives future in-flight chapters
a home.
The masthead, timeline, and live-run telemetry now reflect eleven
experiments with code_drift1 running, and refresh_dashboard.sh
bundles the new page so scheduled publishes carry it. Published as
Litbucket version 36.
In this commit, we add a companion markdown file for each evolved
champion and a README for the directory as a whole. Each per-champion
doc walks the architecture -- the belief state, the probability
model with its actual constants, the route search cost function, the
splitting ladder, and the failure attribution -- and then compares it
point by point against the production stack in routing/, using the
real mission control, estimator, and payment session sources as
ground truth rather than folklore. The comparison corrects one piece
of our own framing along the way: mission control does track per-pair
amount ranges, so the evolved routers' real departures are finer
granularity (directed channel over node pair), permanent hard bounds
over half-life-faded penalties, and settlement displacement (debiting
the forward direction while crediting the reverse), not range
tracking itself.
The docs are honest about shortcomings: the champions were bred in a
simulator that until exp-008 had no background traffic or clock, they
implement the sim's SimRouter contract rather than lnd's Router, the
larger ones carry vestigial code, and hb2's in-flight liquidity
reservation is dead code under sequential shard settlement. The
README frames the directory for an lnd contributor: status and
results tables, the lineage diagram, the shared discoveries, and the
overlay recipe for running any champion against the simulator.
In this commit, we start the exp-008 writeup with the pre-evolution
baseline on the new drift corpus. Two findings land before evolution
even begins: the champions' hard evidence bounds do not collapse when
background traffic moves liquidity under them -- they still beat lnd
by better than two to one on objective at a third of the attempts --
and lnd's decay fails to close the gap even now that the virtual
clock makes its half-lives operate over meaningful time spans. Every
router does lose ground relative to the static regime, so drift
creates the headroom the code_drift1 evolution run now chases.
In this commit, we close the biggest fidelity gap the simulator had:
hidden liquidity only moved when the sender's own payments moved it,
so knowledge never went stale and evidence-based routing strategies
were unbeatable by construction. Real networks keep churning between a
node's sends.
Two additions, both opt-in per scenario file. A virtual clock advances
simulated time between payments (payment_gap_sec) and per attempt
(attempt_sec); the mission control stack behind the lnd baseline is
switched onto the same settable clock, so decay half-lives operate
over simulated rather than wall-clock time, and candidate routers can
read the current time through the new Now() method on SimNetworkView.
A background traffic engine executes seeded payments between random
node pairs in each gap: naive fee-optimizing senders route along the
cheapest public path with no knowledge of hidden balances, retrying
around failed edges a bounded number of times, so only the payments
that genuinely clear move liquidity, hop by hop, with per-channel
conservation.
The traffic sequence depends only on its seed, so competing routers
face the identical exogenous process, and scenario files without the
new sections reproduce their previous results bit for bit. The corpus
generator grows a --drift flag that scales traffic volume with network
size, and the code-mode reflection prompt now describes the drifting
environment neutrally, flagging that the champions' hard liquidity
bounds were learned in a static world, without prescribing whether
time-awareness is the answer -- that is exp-008's question to settle.
In this commit, we write up exp-011: the code_gen2 run seeded from the
small original router with the champions' discovered insights supplied
only as prose in the reflection prompt. The run completed its full 400
eval budget cleanly and accepted 31 candidates, roughly four times
code_mix1's acceptance rate, confirming that small seeds iterate much
faster than champion-sized ones.
The headline result: insight transfer works, but hits the same
ceiling. The best gen2 candidate reaches champion-class performance on
all three held-out tiers (combined 0.638 vs mx_c3's 0.652 and hb1's
0.640, with identical 2.3 attempts/payment on mainnet) yet passes
neither champion. Three independent lineages now converge on the same
interval-belief paradigm and the same performance band, which reads as
a local optimum for the current environments. gen2 also evolved two
novel mechanisms the sim never rewards -- in-flight local liquidity
reservation and weakest-edge failure attribution -- suggesting the
next lever is changing the environment (exp-008 background traffic,
exp-010 splitting pressure) rather than spending more eval budget.
We archive the best candidate source next to the writeup, log the
paradigm-ceiling learning in IDEAS.md, update the notebook and
CLAUDE.md open-work section, and check in the final code_gen2 lineage
data for the command center.
In this commit, we replace the dashboard's console theme with an
editorial report design: a single light paper theme, serif headings
and body with mono reserved for quantitative type, and one oxide
accent used only where it carries meaning. The palette was validated
for CVD contrast against the actual background rather than eyeballed.
We also add findings.html, a standalone write-up of the research so
far: the mainnet validation headlined by the 8.6x attempt reduction,
the paradigm-over-parameters negative result, the three tiers of
held-out evidence, and an anatomy ledger of what the evolved routers
dropped, rediscovered, and invented relative to lnd's stack --
including the honest caveat that the champions' rejection of time
based logic is partly a simulator artifact.
Four hand-drawn SVG diagrams explain the system: the GEPA loop, a
schematic contrasting clock-decayed penalties with evidence-bounded
liquidity intervals, the rediscovered bimodal prior plotted from the
champions' own constants, and the champions comparison chart.
The live-run wiring is hardened for code-mode runs: the candidate
view now detects Go-source candidates, shows line counts and source
diffs, and degrades gracefully on missing exporter fields. Finally,
refresh_dashboard.sh now bundles findings.html, so scheduled
refreshes no longer drop the page from the published site.
In this commit, we consolidate the load-bearing project decisions into
a single log, mirroring the architecture/decisions/experiments notebook
split, so future sessions inherit the why alongside the what.
In this commit, we record the splitting axis explicitly: lnd halves on
a probability threshold, the evolved champions upgraded to an
evidence-derived shard ladder, and joint multi-path planning remains
unexplored — the target for a dedicated splitting-pressure run.
In this commit, we record exp-009: on a real 12,161-node mainnet
describegraph snapshot, the evolved champions match lnd's production
stack on success rate while using 8.6x fewer payment attempts,
settling the synthetic-topology caveat from exp-003.
In this commit, we record the open question raised by the evolved
champions containing no time-based logic at all: the simulator has no
background traffic, so evidence bounds are strictly optimal there in a
way they may not be on a live network where third-party payments move
liquidity between our attempts. The exp-008 design folds into the
batch-2 fidelity work: add a virtual clock and background-traffic model,
re-run evolution, and see whether time-awareness re-emerges.
In this commit, we pick up the dashboard refresh for the new code_gen2
run: the exported lineage data and a live-run note that the small-seed,
insight-enriched follow-up is in flight.
In this commit, we update the quick start to install gepa from the
durable clone at ~/codez/gepa via uv, rather than a throwaway temp
clone that a reboot erases.
In this commit, we add the static command-center site: an overview phase
tracker, live run charts with candidate lineage, a corpus explorer, and
an explainer covering the simulator, mission control's probability
models, and the evolution results. The site is self-contained (no build
step), serves via any static file server, and publishes to Litbucket
through the refresh_dashboard.sh script, which exports a GEPA run
directory into the dashboard's data schema via export_run.py.
In this commit, we check in the artifacts of the first evolution
campaign. The champions directory holds the three GEPA-evolved routers,
all validated on sealed test sets and out-of-distribution corpora
against both the lnd production stack and the hand-written seed:
hb1 (hard-regime specialist), hb2 (superseded OOD sibling), and mx_c3
(the generalist with the best combined average). All are exploit-clean
and independently rediscovered a bimodal liquidity prior with per-edge
liquidity bounds in place of time-decayed penalties.
The lab directory is the running notebook: dated experiment writeups
(exp-001 through exp-007) covering the parameter-tuning null result, the
seed-beats-lnd baseline, the simulator integrity audit, the breakthrough
run, and the follow-up that produced the generalist, plus an ideas
backlog with the engineering learnings.
In this commit, we add the Python harness that drives GEPA's
optimize_anything over the routesim evaluator. Two modes are supported:
parameter mode tunes the existing heuristic's knobs as a JSON candidate,
while code mode evolves the entire routing algorithm as the full Go
source of candidate_impl.go, compiled per-eval via go build -overlay
with compiler errors fed back to the proposer as reflection signal.
The evaluator scores success rate with small saturating penalties for
retry attempts and fees, and guards against reward hacking by rejecting
candidates that reach for unsafe, reflect, or exec surfaces. The
reflection LM runs through the Codex CLI in headless mode via a small
LM-protocol wrapper, and omni-style two-phase composition (parallel
explore, then a fresh engine seeded with the winner) is available
alongside plain and adaptive runs. The background prompt encodes the
insights discovered by prior champion runs so follow-up evolution builds
on them rather than rediscovering them.
