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.
