Contents

• Why — The wall · What Lazarus does
• Does it work? — Six dead repos, resurrected · Reproduces the paper · Measured at scale
• How it works — The Scout writes the plan · Five organs · Runs anywhere
• Use it — Quickstart · Registry & pull · Compose pipelines · decay-check · Dashboard · Give back
• Status · License

The wall

Computational science has a reproducibility problem. A huge fraction of published methods are open, cited, and unrunnable within a few years: the repo is stale, wired to a stack that no longer resolves, and the real capability is buried in scripts with no API. If you're on a small, budget-constrained team, you hit this constantly — the exact method you need exists, but getting it to run costs days you don't have, so it gets abandoned.

What Lazarus does

Lazarus is an agent that revives dead research code, lets you compose the revivals into pipelines, and gives the fixes back to the community.

1. Revive — point it at a bare GitHub URL. Lazarus reads the repo and the paper the way a newcomer would and writes its own goal and sanity check, then runs a build → execute → read-traceback → repair loop in a sandbox. Pin dependencies to the commit era, resolve the binary chain, locate the real capability, and emit a fixed integration contract: an importable module, a CLI, a pinned container, and a smoke test that proves it runs on a fresh input and passes the sanity check it defined.
2. Compose — because every revival emits the same contract, a revived tool is a composable brick. Wire bricks from any domain/language/era into a pipeline with a small YAML; one command runs them, passing artifacts between steps (local / remote / GPU).
3. Give back — the fixes Lazarus finds (rotted URLs, broken paths, a 15-year-old undefined-behavior bug) become maintainer-ready pull requests with CI, so the method can't silently rot again.

Does it work?

Six dead repos, resurrected autonomously

Each revived from its own dead environment using only general heuristics (no repo-specific notes), each emitting a callable package that passes its own smoke test standalone:

The dMaSIF run built a whole CUDA/KeOps GPU environment from a bare image and patched a source bug to unlock GPU execution the original forced to CPU. The fpocket run fought a SourceForge download interstitial, a modern-ld link-order break, and a 15-year-old overlapping-sprintf undefined-behavior bug that modern glibc exposed. Genuinely different resurrection flavors — TF / CUDA / 2010-C.

Then we pointed it at fields it had never touched, from nothing but a link. From github.com/davek44/Basset — a 2016 Lua Torch7 genomics CNN — the agent cleared a new class of decay (a 2016 Docker manifest modern Docker refuses to pull, converted with skopeo) and caught a silent scientific-correctness bug: the naive run scored mean AUROC 0.675, but the agent traced it to hg19's soft-masked lowercase bases falling through Basset's uppercase-only one-hot encoder, patched it, and reproduced the paper — mean AUROC 0.8944 vs 0.895 across all 164 cell types. And from github.com/gcorso/DiffDock — the ICLR-2023 diffusion molecular-docking model — it revived on GPU, and when the shipped example wouldn't honestly clear DiffDock's own < 2 Å bar, it reproduced the model's ~40 % top-1 rate instead of faking a pass, landing a 0.35 Å hero dock (6MOA). It refused to ship a green checkmark it hadn't earned. Details: docs/CHALLENGES.md.

Three-way head-to-head (the three site predictors, scored by one script on identical PD-L1 residue labels): ScanNet 0.915 · dMaSIF 0.854 · MaSIF 0.823. All localize the interface (a 13-residue consensus core); the two surface methods (MaSIF & dMaSIF) agree most (Spearman ρ 0.70). Details: paper/analysis/RESULTS.md.

Reproduces the paper

A smoke test proves a method runs; a benchmark proves it's the method. Lazarus re-ran MaSIF-site on its own transient PPI benchmark — through the built-in download that give-back PR #93 revived — and matched the published number:

Every revival can carry this: the contract's benchmark field emits a REPRODUCE.md certificate with a PASS/OFF verdict — the trust layer that turns a resurrection into something a team will actually adopt.

Measured at scale

The hero repos are anecdotes. To test the thesis honestly we measured decay and revival on seeded random samples, every verdict independently re-verified — the frames, seeds, and per-repo outcomes all live in benchmark/.

First, in one field (N=20, Bioinformatics 2018–2021):

Then across science, and across peer review — a controlled study (preprint). Lazarus has now revived 40+ repos across a dozen fields (astronomy, materials/DFT, plasma physics, hydrology, thermodynamics, retrosynthesis…), and we used its agent-free decay-check to compare peer-reviewed software (JOSS, N=173) against unreviewed code linked in papers (N=257):

Both gaps are statistically significant — yet the agent revives reviewed and unreviewed code equally well. The finding: the reviewed/unreviewed gap is packaging discipline, not recoverability. Peer review predicts whether code installs, not whether the science can be brought back. Full methods: paper/CROSSDOMAIN_METHODS.md; per-repo data: paper/supplement/.

How it works

Point it at a URL — the Scout writes the plan

You don't hand Lazarus a goal; you hand it a link. A web-enabled Scout reads the repo and paper (and only those — never your notes) and drafts the whole plan: the capability to revive, a base image, and a falsifiable sanity check. Then it pauses for your OK before spending a turn.

lazarus resurrect https://github.com/jertubiana/ScanNet

Run cold against ScanNet with no hints, the Scout reconstructed — from the URL alone — a plan matching the one a human expert hand-wrote after days of work: