Lazarus

Turn dead research code into a callable pipeline component — and give the revival back.

🏆 Winner — Build track, Claude Science hackathon · July 2026

New here? Open the notebook in Colab — a 2-minute, zero-setup tour (no Docker, no GPU): run the dependency pinner live, inspect the revived tools, and see the binder-triage result rendered in 3D.

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 ML-for-biology 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.

Proof — four 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. Three genuinely different resurrection flavors — TF/CUDA/C.

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: analysis/RESULTS.md.

Point it at a URL — it writes its own 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:

That's the democratization step: the expert judgment of what "revived" even means becomes something you get from pasting a link.

Then we pointed it at a repo we'd never touched, in a different field entirely. From just github.com/davek44/Basset — a 2016 Lua Torch7 genomics CNN (chromatin accessibility from DNA sequence) — the Scout planned it and the agent revived it end to end. Along the way it cleared a new class of decay (the README's 2016 Docker image ships a 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. A fifth brick, a new domain (genomics, not protein surfaces), a fourth dead framework — from a link. Details: docs/CHALLENGES.md §5.

And the one that shows the integrity of the sanity check: from github.com/gcorso/DiffDock — the ICLR-2023 diffusion molecular-docking model, ~2 years stale — the Scout revived it on GPU. Its shipped example is a hard case (top-1 ~5 Å, under DiffDock's own < 2 Å bar), so rather than fake a pass, Lazarus docked 8 complexes from DiffDock's own test set, reproduced its ~40 % top-1 success rate, and found a rock-solid hero case (6MOA: RMSD 0.35 Å — the predicted pose sitting on the crystal ligand). It refused to ship a green checkmark it hadn't earned. Details: docs/CHALLENGES.md §6.

Compose — an in-silico pipeline from revived bricks

examples/pipelines/binder_triage.yaml assembles methods that were each individually unrunnable a week ago into one binder-triage pipeline:

structure ─▶ ScanNet ─┐
          ─▶ dMaSIF ──┼─▶ consensus ─▶ interface residues that also line a druggable pocket
          ─▶ fpocket ─┘

lazarus run examples/pipelines/binder_triage.yaml \
  --input structure=4ZQK.pdb \
  --registry examples --registry components \
  --docker-host ssh://you@your-x86-gpu-box

Run live on PD-L1, it concluded: 27 interface residues (115, 123, 56, 121, 113…), but 0 druggable pockets → "the interface is clearly localized but not a druggable small- molecule pocket — a flat protein-protein interface, i.e. an antibody/biologic target." That's textbook immuno-oncology (PD-1/PD-L1 is an antibody target), reproduced from dead code. Sample output: examples/pipelines/sample_output_4ZQK/.

Give back

For the genuinely-abandoned repos, Lazarus prepares maintainer-ready PRs — the real fix plus a CI smoke test so it can't silently rot again:

• MaSIF — PR #93 — the rotted PDB download, fixed (direct RCSB fetch); verified to revive the built-in flow at ROC-AUC 0.9137. → giveback/masif/
• ScanNet — PR #16 — library_folder='' made to auto-detect the repo root; verified. → giveback/scannet/

(dMaSIF is skipped — CC BY-NC-ND, no-derivatives; fpocket's upstream is alive.)

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 — most of these repos are dead, and Lazarus revived them all

The hero repos above are anecdotes. To test the thesis honestly we drew a principled, seeded random sample — 20 tools published in Bioinformatics (2018–2021) — and ran two passes over each: an agent-free baseline (does it still run today?) and the full Lazarus harness (can the agent revive it?), with every verdict independently re-verified.

85% of a random slice of recent, peer-reviewed computational biology won't install or run a few years on. Lazarus brought back every dead repo in the sample — 20 / 20 overall — and 5 matched the original paper's numbers. Nothing here is cherry-picked: the frame, the seed, the per-repo outcomes, and the runnable harness are all in benchmark/ (benchmark/report.py regenerates the table with confidence intervals).

How it works — five organs

Runs on a laptop, executes anywhere

Lazarus runs on your machine; where it executes is pluggable via one flag — a local container, a remote x86 box, a cloud VM, or a GPU rental — for methods (like MaSIF's MSMS or dMaSIF's CUDA) whose binaries need hardware laptop emulation can't provide. The agent's tools and the emitted predict.py both run against whatever --docker-host / DOCKER_HOST points at, so the whole chain is host-agnostic.

The registry — pull a revived tool

Every revival lands in a living registry, so you don't have to re-resurrect what someone already did. Browse it and pull any tool's contract — an importable module, a CLI, a pinned container, and the smoke test that proves it runs:

lazarus registry                              # list the revived tools
lazarus pull scannet_ppi_binding_sites        # fetch its contract bundle

13 tools are in today — the protein-surface / docking / genomics hero set (MaSIF-site, ScanNet, dMaSIF, fpocket, Basset, DiffDock) plus benchmark revivals like HiTEA, DnaFeaturesViewer, CoCoNet, EquiDock, and EquiBind — most backed by a public, pullable image on GHCR (see docs/IMAGES.md to run one). Adding a tool is a pull request: see CONTRIBUTING.md.

Try it — the dashboard

A public "try it" surface: search a GitHub repo, watch it come back to life, browse the registry.

uvicorn demo.dashboard.app:app --port 8080    # → http://localhost:8080

Is it dead? Measure it — decay-check

The agent-free flip side of reviving: does a repo still install and run today? — the same signal behind the 85% number. No agent, no API key.

lazarus decay-check https://github.com/owner/repo      # RUNS / DECAYED + a reason code

It's also a GitHub Action — drop it in any repo's CI as a reproducibility canary that goes red the day the code stops running:

- uses: DoctorDean/lazarus/actions/decay-check@v0.3.0
  with: { fail-on-decay: true }

Quickstart

pip install lazarus-bio                      # the tooling: pinner, compose, contracts
pip install "lazarus-bio[agent]"             # + the autonomous revive loop & Scout (Python ≥ 3.10 + Docker)
# or, to hack on Lazarus itself:
#   git clone https://github.com/DoctorDean/lazarus && cd lazarus
#   pip install -e ".[dev,agent]"

# commit-era dependency pinning — no repo execution required
lazarus pin --date 2019-01-01 tensorflow numpy scipy
#   tensorflow==1.12.0   (matches MaSIF's real Dockerfile, not its README)

# resurrect straight from a URL — the Scout writes the goal + picks the image,
# then pauses for your OK before spending compute (needs Docker + Claude auth)
lazarus resurrect https://github.com/jertubiana/ScanNet

# …or drive it by hand with an explicit image + goal (both override the Scout)
lazarus resurrect --image pablogainza/masif:latest --workdir /masif \
  --goal-file examples/masif_site_goal.txt --keep

# browse & pull from the registry of already-revived tools
lazarus registry
lazarus pull scannet_ppi_binding_sites

# compose revived components into a pipeline
lazarus run examples/pipelines/binder_triage.yaml --input structure=4ZQK.pdb \
  --registry examples --registry components

Auth: Lazarus drives Claude via the Claude Agent SDK. Log in the claude CLI (subscription) or put ANTHROPIC_API_KEY=... in a gitignored .env.

Status

Working today: Scout (URL → resurrection plan) · pinner · Docker sandbox (local + ssh:// remote + --gpus) · autonomous repair loop · capability locator · contract emitter (GPU-aware, with reproduction certificates) · Lazarus Compose · a registry of revived tools · a public dashboard · an agent-free decay-check (CLI + GitHub Action). All three pillars landed — a hero set of dead repos revived (protein + genomics + molecular docking), a three-way method comparison, a live binder-triage pipeline, reproduced paper benchmarks, and two give-back PRs — plus a principled N=20 benchmark (85% of the sample dead, 100% of the dead revived; see benchmark/) and a registry grown to 13 tools. 72 passing tests, published to PyPI (pip install lazarus-bio).

Contributions welcome — add a repo, curate a registry entry, or file a revival that failed. Start at CONTRIBUTING.md. Development happens on the next branch.

Two front doors: a zero-setup Colab notebook for newcomers (no Docker/GPU — pinner live + the result rendered in 3D), and the interactive dashboard — search a repo, watch it come back to life, and browse the registry.

License

MIT — see LICENSE.