Skip to content

What is bindsight, and why does it matter?

A 5-minute read for anyone — biologist, data scientist, PI, investor, or recruiter — who wants to understand what this tool is, what it does, and why it's a genuine deal-breaker rather than yet another wrapper.

The one-sentence pitch

bindsight joins cohort RNA-seq target discovery to de novo protein binder design in one reproducible workflow, and keeps a machine-readable audit trail from every ranked binder back to the patient samples the target came from.

That's it. Counts in, designed binders out, every step documented.

Neither half is new on its own — that is the point. Binder-design workflows (BindCraft, BinderFlow, dl_binder_design, nf-proteindesign) begin at a target you have already chosen; expression- and surfaceome-based target discovery (pan-cancer surfaceome screens, pVACtools for neoantigens) ends at a ranked gene or peptide list. As far as we are aware, bindsight is the first open-source tool that runs both halves end-to-end and carries provenance across the join. The individual steps belong to the community; the join, its defaults and its receipts are what bindsight adds.

The two worlds it bridges

In computational biology in 2026, two ecosystems run side-by-side and barely talk to each other:

World Tooling Where it stops
Genomics DESeq2, edgeR, Seurat, scanpy, TCGA, recount3, GTEx "Here are the differentially-expressed genes."
Protein design RFdiffusion, ProteinMPNN, BindCraft, BoltzGen, AlphaFold, Boltz-2, Chai-1 "Given this target structure, here are some designed binders."

Between them sits a chasm. Going from "this gene is interesting" to "here's a protein I designed to bind it" requires:

  1. Mapping gene IDs → UniProt accessions
  2. Filtering for surface-exposed proteins (else you can't drug them)
  3. Filtering for tissue specificity (else you'll hit healthy organs)
  4. Pulling structures from AlphaFoldDB or PDB
  5. Identifying druggable epitopes on those structures
  6. Running a backbone diffusion model (RFdiffusion, etc.) on each
  7. Designing sequences with ProteinMPNN
  8. Validating each design with Boltz-2 / AlphaFold
  9. Multi-objective ranking
  10. Tracking provenance so a reviewer can audit the chain

Today, doing all of this for one disease takes a competent grad student 4–6 weeks of glue scripting, four different conda environments, and at least one HPC allocation. The work is rarely reproducible across labs. The Apr 2026 bioRxiv preprint that did it for one cancer (DSRCT) needed a custom agent framework just to keep state.

bindsight does it in a single command, on a CPU laptop, with reproducibility that survives review.

Why this is a deal-breaker, not yet-another-wrapper

1. It closes a structural gap, not a polish gap

As far as we are aware, no other open-source tool takes RNA-seq counts as its input type. ProteinDJ, Ovo, BindCraft, dl_binder_design, nf-binder-design, and Tamarind.bio all start with "give us a target structure." They polish the protein-design half of the pipeline. The discovery half — the genomics-to-structure bridge — is where we live, and where we have not found a shipped open-source equivalent.

2. The keystone (SURFACE-Bind) just dropped

The SURFACE-Bind catalog (PNAS 2026) ships pre-computed targetable interfaces + binder seeds for ~2,800 surface proteins under a BSD-3 license. Before this, "find a druggable site on an arbitrary surface protein" was its own project. Now it's a UniProt-keyed lookup. This unlocks the bridge for a one-person team — exactly the right moment to build.

3. CPU laptop is enough

The orchestrator runs on the user's machine. GPU work is dispatched to a free Kaggle T4×2, a paid Modal A100, a local NVIDIA GPU or a Colab notebook — the user picks the backend per command. Only Kaggle has been run end to end, and it is the backend the committed benchmark used; Modal and local Docker are implemented but unexercised, and Colab needs a human with a browser tab open because Google's API will not launch a free-tier notebook from a CLI.

The user's $0/month research budget is no longer the bottleneck; the same setup that works for a PhD student in Cairo works for a clinician in Lagos.

4. Provenance is the moat

Every binder PDB the pipeline outputs is one click from:

  • the patient cohort it came from,
  • the differential-expression statistics that flagged the target,
  • the AlphaFoldDB structure used,
  • the SURFACE-Bind site predicted,
  • the trajectory seed and the resolved design parameters,
  • the validator metrics,
  • the image digest of any containerised step, where that image was pulled by digest.

This is recorded as a PROV-O JSON-LD manifest and packaged as an RO-Crate — both W3C/FAIR-friendly standards. Reviewers can audit the chain. Clinicians can defend the choice in IND filings. We have not found another protein-design tool that offers this.

5. Failure-honest by default

The pipeline catalogs why targets fail (no AlphaFoldDB model, no SURFACE-Bind site, fails specificity, designer fails to converge, validator rejects), publishing a failure_taxonomy.parquet next to the successes. Every open binder-design tool we compared above quietly drops failures. We surface them, because that's what users actually need to triage.

6. Commercially defensible

The default config uses MIT / Apache / BSD code and CC0 / CC BY data, with one exception the inventory marks: the SURFY surfaceome list, whose source states no terms. Every non-permissive opt-in (the AF2-IG validator, through PyRosetta) is behind a CLI banner and documented in LICENSING.md. A pharma early-discovery team can read exactly what it would be running before legal review, rather than after.

What you can do with it

Discovery half — CPU, no GPU

bindsight discover examples/tcga_luad.yaml --out runs/luad_v01

Produces:

  • runs/luad_v01/deg/results.parquet — DEG table from pydeseq2
  • runs/luad_v01/targets/candidates.parquet — surface-restricted, druggable, tissue-specific target shortlist
  • runs/luad_v01/epitopes/epitopes.parquet — top-N candidates with structure paths
  • runs/luad_v01/run_manifest.jsonld — PROV-O audit trail

Useful right now if you're a translational researcher trying to triage a cancer cohort for surface-antigen targets without writing 600 lines of glue.

Design + validation half — GPU-backed

bindsight design runs/luad_v01 --backend kaggle --trajectories 50
bindsight validate runs/luad_v01 --backend kaggle --validator boltz2
bindsight rank runs/luad_v01
bindsight report runs/luad_v01 --format html

Adds:

  • Per-target de novo binder PDBs from RFdiffusion + ProteinMPNN
  • Boltz-2 affinity + iPTM scores per design
  • Composite ranking
  • Self-contained HTML report (embedded volcano plot + tables + PROV-O manifest)
  • RO-Crate export for deposit in a research data repository

Validation (done — discovery half)

A companion report runs the discovery half on 15 whole, unstratified TCGA projects. It surfaces CA9 at rank 1 of 291 in clear-cell kidney, alongside GPC3, MET, FOLH1 and STEAP1. Cohorts are whole, unstratified TCGA projects, so nothing in a cohort's definition refers to the antigen being sought. Recall at rank 20 is 1 of 17 on approved-agent antigens (95% CI 0.01–0.27). Most validated antigens are simply not significantly over-expressed in an unstratified bulk contrast, which is a limit of the signal rather than of the ranking, and the study says so. Reproducible artifacts are in benchmarks/study/.

The discovery half also carries two null models, and they point in opposite directions. Against decoys matched on abundance and dispersion, no antigen in the panel is distinguishable once the panel is corrected for its own size — a negative result, and the study reports it as one. But the ranking is indication-specific, and two separate analyses say so.

The null itself is a permutation test: against every reassignment of cohorts to antigens, the mean standing is 0.858, with an exact permutation p of 3.97e-04 over all 5,040 orderings — 5,040 being 7!, because that test covers only the 7 antigens carrying a single indication.

Calibrating it, KICH and THCA carry no panel antigen at all, and known antigens sit at mean standing 0.765 in the cancer they are actually used in against 0.417 there: a within-antigen difference of 0.348 (95% CI 0.188–0.513), cluster-bootstrapped over 13 antigens, each antigen its own control. That difference carries an interval and no p-value; the permutation p above belongs to the 7-antigen test and is not its significance, which no test reports.

The indication-specificity null is the strongest claim this project makes, and it is about the ordering, not about any single hit.

Validation (the design half — and what it does not show)

The design half runs end-to-end on a free GPU and produces real Boltz-2 structures. What it does not establish is that those designs bind.

A paired control folded each design beside a shuffle of its own sequence — same length, same amino-acid composition, only the order destroyed. Under a seeded validator averaging five diffusion draws, the shuffles cleared the 0.65 confidence bar more often than the designs: 50% against 30%, a paired difference of −0.043 (95% backbone-cluster CI −0.137 to +0.063), with 9 of 20 designs beating their own shuffle where 10 is chance. success@0.65 is therefore withdrawn as a measure of design quality, and this page will not quote it as one. The full control, including the predictions written down before the data arrived, is in benchmarks/calibration/.

The three-way designer benchmark that would compare RFdiffusion+ProteinMPNN against BindCraft and BoltzGen is GPU-only and not yet run: both alternatives need 24–32 GB against anything larger than a small domain, and no shipped backend builds an environment where they run. A runnable, CPU-tested harness and protocol ship in benchmarks/designer_benchmark/.

v1.0

Multi-modal tumor-selectivity scoring (single-cell + co-expression + immunopeptidomics) to extend discovery beyond bulk differential expression, plus the populated designer benchmark.

Who this is for

Audience What they get
Translational researcher with a TCGA cohort and limited compute A reproducible "data → designed binder" pipeline without paying SaaS prices
Clinical biologist who needs an audit trail A PROV-O / RO-Crate trace from binder back to expression evidence — defensible at thesis defense and useful for IND filings
Method developer building a new designer or validator A held-out evaluation harness (rediscovery of known antigens) to benchmark against a fixed upstream pipeline
Pharma early discovery team A free open-source comparator they can layer their proprietary designers into via the plugin interface
Educator teaching computational biology A working end-to-end example that touches DEG, structural biology, deep learning, and software engineering — in one repo

What it is NOT

  • Not a wet-lab pipeline. Output is in silico binder candidates. Wet validation (yeast display, biolayer interferometry, etc.) is the user's job.
  • Not a regulated GxP tool. The provenance graph is a starting point for an audit trail, not a substitute for a GxP-validated system.
  • Not a structure predictor itself. It wraps Boltz-2 / Chai-1 / AlphaFold; the predictions are theirs, attributed in every manifest.
  • Not a replacement for domain expertise. A surface-protein hit list still needs a human to apply biological judgment about safety, specificity, immunogenicity, and developability.

The honest limits in v0.x

We're transparent about what doesn't work yet. From ARCHITECTURE.md § 10:

  • pydeseq2 is not bit-equivalent to R DESeq2 (documented)
  • SURFACE-Bind covers ~2,800 surface proteins, not all of them (graceful drop)
  • Free Colab sessions die mid-job (per-trajectory checkpointing mitigates)
  • Designer choice (RFdiff vs BindCraft vs BoltzGen) will keep evolving (plugin interface; the rfdiff_mpnn arm is benchmarked today — see the designer benchmark — with BindCraft/BoltzGen on paid ≥24–32 GB GPUs as it grows)
  • mRNA abundance is not cell-surface protein abundance — SURFY confirms a protein can reach the surface, not how much is actually there. Surfaced candidates are hypotheses to confirm at the protein level (flow cytometry / IHC / Human Protein Atlas) before trusting them. (Stated in every run's report Limitations section.)
  • Bulk expression can come from non-tumour cells — high apparent over-expression may reflect infiltrating immune/stromal cells or tumour purity rather than a tumour-intrinsic target; single-cell / deconvolution evidence is needed to be sure (the multi-modal tumour-selectivity layer for v1.0).
  • Disease specificity is hard, and the signal is weaker than this page used to claim — "up in cancer, low in vital tissue" does not predictably find known antigens. Recall at rank 20 is 1 of 17 on approved-agent antigens (95% CI 0.01 to 0.27). A multi-modal tumour-selectivity layer is the plausible route to a stronger signal, and none of it is implemented.

Why this is the right project at the right time

  • The OSS protein-design stack just consolidated. Boltz-2 (MIT, code + weights), BoltzGen (MIT), Chai-1r (Apache-2), and BindCraft (MIT) all shipped permissive licenses in 2025. A year earlier, the "what validator do we ship?" question had no clean answer.
  • SURFACE-Bind closed the epitope-prediction gap for a meaningful slice of the surfaceome. Before late 2025, you'd have built that yourself.
  • Free GPU tiers (Colab T4, Kaggle T4×2) became powerful enough to run RFdiffusion + ProteinMPNN at meaningful scale. A year earlier, you'd have needed an institutional cluster.
  • Cancer omics is publicly available (TCGA, recount3, GTEx) — the upstream data is already in the open.
  • The clinical translation gap is widely acknowledged (e.g. Springer J Transl Med 2026). Reviewers want to see the bridge built.

All five conditions — permissive validators, the SURFACE-Bind catalog, free GPU, open cancer omics, and acknowledged demand — held simultaneously starting in late 2025. That's the window.

How is this different from "just calling AlphaFold + RFdiffusion"?

Anyone with a GPU can run the existing tools. The work bindsight does is the opinionated, validated, reproducible join. Specifically:

  1. Empirical defense of the defaults. The discovery half is validated by rediscovery on fifteen real TCGA cohorts (benchmarks/study/): it surfaces CA9 at rank 1 of 291 in clear-cell kidney, and antigens that aren't transcriptionally over-expressed stay out of the shortlist — an internal consistency check on the over-expression rule, not a specificity measurement, since that rule excludes them by construction. See the validation report.
  2. Container-pinned, seed-pinned, weights-pinned reproducibility. Two runs of the same config on the same data should produce identical artifacts, modulo logged stochastic seeds. The manifest itself is not byte-identical between runs and is not meant to be: run_id is a fresh UUID4, and created_at and every stage's timestamps record when the run happened. What is comparable across runs is the content — each artifact's SHA-256, and the resolved tool and container versions beside it. Seed-pinning covers the executed path — RFdiffusion, ProteinMPNN, Boltz-2 and Chai-1 each take the run's seed. It does not cover BindCraft or BoltzGen, which expose no way to set one at their pinned commits; the executor warns when either runs.
  3. Negative-result curation. A failure_taxonomy.parquet per run — every target that didn't make it, with a reason.
  4. Cost-aware orchestration. --dry-run estimates GPU $ before running. Existing tools assume HPC and don't think about cost.
  5. Plugin-not-fork extensibility. New designers / validators / runners ship as separate Python packages that register via entry points. Nobody has to fork to extend.

Summary

Two ecosystems that should be one. A keystone catalog (SURFACE-Bind) that just shipped. Permissive validator licenses that just landed. Free GPU tiers that just got good enough. Public cancer omics. A reproducibility crisis everyone agrees on. One person can connect all of this for the first time. That's bindsight.

If you want the architectural detail, see ARCHITECTURE.md. If you want to use it now, see how-to-use.md. If you want to see what it can do, see use-cases.md.