Recovering from Bad Docking: Fault Attribution for Hierarchical Protein Assembly

When a computational method assembles a large protein complex — tens of chains that must fit together in one precise 3D arrangement — it faces the same trap a biological cell faces. If every subunit tried to bind at once, the system would fall into disordered aggregates. Biology solves this with hierarchical assembly: pioneer proteins first form a structural scaffold, and cooperative conformational switches then gate the ordered recruitment of secondary cargo, as documented for transcription hubs (Nanog organizes transcription bodies), centriolar distal appendages (A ciliopathy complex builds distal appendages to initiate ciliogenesis), and the kinetochore KMN network (Structure of the human KMN complex and implications for regulation of its assembly). Computational assembly has begun to copy the hierarchy — but not the other half of biology's trick: the ability to detect and undo mistakes mid-assembly.

Two computational systems currently lead large-complex assembly, and both are brittle in complementary ways. GAPN (Deep Reinforcement Learning for Modelling Protein Complexes) learns a policy that sequentially docks chains, formulating assembly as a Markov Decision Process, but it is strictly additive: the authors state plainly that one erroneous early docking propagates unchecked through every later step, with no mechanism to undo it. MoLPC2 (MoLPC2: improved prediction of large protein complex structures and stoichiometry using Monte Carlo Tree Search and AlphaFold2) backtracks via Monte Carlo Tree Search, but only blindly: a bad branch gets a low score and is abandoned through generic rollouts, at a computational cost that GAPN reports as a 600x slowdown relative to learned policies, and that confines MoLPC2 to symmetric complexes. Meanwhile, the agent literature has built exactly the machinery this requires: $R^3$DAO ($R^3$DAO: Reactive Recovery and Reconstruction for Long-horizon Data Agent Orchestration) repairs execution graphs with localized operations — refine a node, insert a missing prerequisite, skip a non-critical failure — instead of restarting; Aegis (Aegis: Automated Error Generation and Attribution for Multi-Agent Systems) and AgenTracer (AgenTracer: Who Is Inducing Failure in the LLM Agentic Systems?) attribute failures to the decisive step in an interacting system, enabling targeted correction. None of this has ever touched a physical, spatial, molecular assembly process.

Core Claim

I propose to build an assembly system with a working repair loop: after each docking event, a detector checks for silent assembly errors (plausible local interfaces that violate global constraints — steric clashes, broken symmetry, inconsistent predicted contacts); when one is found, an attribution module identifies which placed chain and which docking step caused it, using counterfactual replay in the style of AgenTracer; and a repair module then applies localized surgery to the assembly dependency graph — re-dock the offending subunit against alternative conformers, insert a missing intermediate sub-component, or skip a bad branch — rather than restarting or blind re-rollout. The hierarchy comes from biology's playbook: assembly proceeds scaffold-first, with scaffold sub-assemblies acting as macro-anchors that gate which secondary docking operators become available, mirroring how the Mis12 complex in the KMN network (Structure of the human KMN complex and implications for regulation of its assembly) must bind before downstream partners can. The repair logic comes from $R^3$DAO's Reactive Topology Reconfiguration, translated from code graphs to structural graphs. The hypothesis: targeted repair guided by attribution will resolve more large complexes at lower compute than either forward-only policies (GAPN) or undirected tree search (MoLPC2).

Research Program

The system, which I will call ReDock, has three parts sitting on top of an existing sequential assembly backbone (GAPN's PPO dock-next policy, or MoLPC2's sub-component docking where sub-assemblies are pre-computed by AlphaFold-Multimer).

First, the assembly graph. Assembly is represented as a directed graph whose nodes are sub-assemblies (dimers, trimers, tetramers — following MoLPC2's observation that tetramer sub-components raise mean TM-score from 0.49 to 0.54) and whose edges are docking events, organized in two tiers: scaffold nodes, docked first, and cargo nodes, docked only once their gating scaffold exists. This directly encodes the division of labor observed in the neuronal membrane skeleton, where a foundational lattice is a mandatory recruiting platform for secondary cargo (Proteomic and functional analyses of the periodic membrane skeleton in neurons). Practically, the hierarchy also constrains the search: when repair is needed, only the affected sub-tree downstream of the faulty node is invalidated, exactly as OrchDAG isolates dependent paths in a plan DAG (OrchDAG: Complex Tool Orchestration in Multi-Turn Interactions with Plan DAGs).

Second, silent-error detection and fault attribution. Following the finding of Tools Fail: Detecting Silent Errors in Faulty Tools that agents accept plausible-but-wrong outputs, the detector will not trust local interface scores alone; it will verify global preconditions (clash-free geometry, symmetry consistency, contact-map agreement with per-interface predictions). Attribution then adapts AgenTracer's counterfactual-replay recipe to structure: replay the partial assembly with candidate docking events removed or replaced, and train a model — initialized from a protein language model, trained with counterfactual pairs and a step-level reward in the spirit of AgenTracer's GRPO setup — to predict the decisive faulty placement. The Aegis result that identifying the responsible component is much easier than diagnosing the error mode (Aegis: Automated Error Generation and Attribution for Multi-Agent Systems) sets expectations here: "which chain" attribution should be learnable first; "which alternative docking mode" is the harder second stage.

Third, localized repair. Three operations on the assembly graph, mapped from $R^3$DAO's Refine/Insert/Skip: Re-dock (re-run the faulty docking with an alternative conformer or alternative AFM-ranked sub-prediction — MoLPC2 shows the top-ranked AlphaFold-Multimer prediction is often suboptimal, motivating sampling across all five AFM models), Insert (add a missing intermediate sub-component whose absence blocks the gated recruitment, analogous to $R^3$DAO inserting missing prerequisite nodes), and Skip (abandon a sub-assembly that a higher-scoring path makes redundant). Repair is budgeted: if two consecutive repairs of the same region fail, the region's scaffold is re-docked rather than the whole complex restarted.

A key methodological deliverable beyond the system itself is an assembly fault-injection benchmark: taking the 175-complex set used by MoLPC2 and the 180-complex set used by GAPN, deliberately corrupt successful trajectories at controlled steps (a swapped conformer, a wrong interface orientation, a skipped intermediate) with Aegis-style adaptive injection, yielding labeled (trajectory, faulty step, faulty chain) triples on which recovery rate, attribution precision, and repair compute can be measured — the structural analog of Aegis-Bench. No such benchmark exists on Lacuna for protein assembly.

Proposed Experiments

Three experiments, in order of decisiveness. All use the two structural test sets in the file: the 180 nonredundant PDB complexes (3–30 chains, ≤50% sequence similarity to training data) on which GAPN reports a 31% TM-score improvement for complexes with at least 11 chains over prior assembly methods, and the 175 nonredundant complexes (10–30 chains) on which MoLPC2 correctly predicted 50 structures with TM-score at least 0.8 without knowing stoichiometry.

The first experiment measures end accuracy under equal compute. ReDock, GAPN, and MoLPC2 each get the same GPU budget and the same AlphaFold-Multimer sub-component predictions as input. Primary metrics: fraction of complexes with TM-score ≥ 0.8, mean TM-score, and wall-clock time per complex, reported separately for symmetric and asymmetric complexes (since MoLPC2's weakness is asymmetric architecture). Success for ReDock means beating GAPN's TM-score on large complexes while staying within an order of magnitude of its runtime, and beating MoLPC2's 50-of-175 resolution rate at lower total compute.

The second experiment measures recovery directly, on the fault-injection benchmark. Inject faults at controlled depths (early scaffold placement vs. late cargo docking) and measure: recovery rate (final TM-score ≥ 0.8 despite injection), attribution precision (does the identified faulty chain/step match the injected one), and repair cost (number of docking recomputations). This is where the mechanism, not just the headline accuracy, is tested. The comparison that matters most here is against undirected re-search: MoLPC2-style rollouts given the same repair compute. If attribution-guided repair does not beat undirected re-expansion at matched compute, the core claim fails and I would say so.

The third experiment isolates the hierarchy. Run ReDock with the two-tier gating replaced by flat sequential docking (all operators available at all times, as in GAPN), keeping the detector and repair modules identical. This tests whether scaffold-first ordering independently reduces the rate of silent errors and shrinks the repair sub-tree — the biological claim translated into a measurable engineering claim, in the spirit of the Nanog result that scaffold clustering precedes and is independent of downstream activity (Nanog organizes transcription bodies).

Baselines

The naive reference point is single-shot end-to-end folding with AlphaFold-Multimer: give the model all chains and the correct stoichiometry and ask for the whole complex in one pass. This is the "do nothing" comparator because it requires no assembly machinery, but it fails the use case this proposal targets — MoLPC2 established that AlphaFold-Multimer needs stoichiometry specified in advance and that its top-ranked prediction is often suboptimal even given correct sub-components, and GAPN reported a 31% TM-score improvement over prior methods for complexes with at least 11 chains, a regime where single-pass folding exhausts memory. It will be run on the same test sets with the same AFM checkpoints, and beating it is a floor, not a target.

The strongest policy-based competitor is GAPN (Deep Reinforcement Learning for Modelling Protein Complexes), which on its 180-complex test set reports a 31% TM-score improvement for large complexes ($N \geq 11$) and a 600x speedup over MoLPC. It is the strongest competitor because it is the fastest accurate method and represents the "get it right the first time" philosophy — if forward-only assembly is good enough, repair machinery is dead weight. Fair comparison means running the published GAPN policy with identical sub-component inputs, the same GPU budget, and the same hyperparameter search allowance, and evaluating on the identical test split. ReDock beats it if it achieves higher mean TM-score on complexes with $N \geq 11$ while remaining within 10x of GAPN's runtime — the added repair must cost less than the errors it removes — and decisively beats it on the fault-injection benchmark, where GAPN structurally cannot recover.

The strongest search-based competitor is MoLPC2 (MoLPC2: improved prediction of large protein complex structures and stoichiometry using Monte Carlo Tree Search and AlphaFold2), which resolved 50 of 175 complexes at TM-score ≥ 0.8 without stoichiometry knowledge (mean TM-score 0.49 to 0.54 with tetramer sub-components). It is the strongest competitor for the unknown-stoichiometry setting, which is the realistic discovery regime. It will be run with its published MCTS configuration, the same sub-component library, and matched total compute; ReDock beats it by resolving more than 50 of the 175 complexes at TM-score ≥ 0.8 at equal or lower compute, with the asymmetric-complex subset as the sharpest differentiator given MoLPC2's reported combinatorial breakdown there.

The key ablation replaces the attribution module with a score-based heuristic: on detecting an error, backtrack to the lowest-scoring recent docking event and re-sample it uniformly. This isolates whether learned fault attribution — the Who&When machinery transplanted from AgenTracer — adds anything over cheap structural heuristics. If the heuristic matches ReDock's recovery rate at similar compute, the interesting result is the heuristic, and the proposal's learned component would be dropped; I would rather report a working simple method than defend an unnecessary model.

Why not just…?

Why not just run AlphaFold-Multimer end-to-end on the whole complex? For small complexes, this is likely to win, and I would concede that regime. The evidence against it at scale is direct: GAPN's assembly policy beat end-to-end approaches by 31% TM-score on complexes with 11 or more chains, and the factorial growth of the assembly space ($N^{N-2}$ configurations) makes single-pass folding intractable or memory-bound there; MoLPC2 further showed AlphaFold-Multimer requires stoichiometry in advance and that its top-ranked sub-prediction is often not the one used in the true assembly. The proposal targets exactly the regime (large, unknown-stoichiometry, partially asymmetric) where the file's evidence says single-pass fails; the matched-compute comparison against it on the 175-complex set will make the boundary explicit rather than assumed.

Why not just use MCTS, which already backtracks? This is the most serious alternative, and I want to be honest about that. MoLPC2's tree search does recover from dead ends, and for symmetric complexes it may remain competitive. Three pieces of evidence say undirected search under-delivers where recovery matters: MoLPC2 resolved only 50 of 175 complexes and breaks down on asymmetric architectures; GAPN measures learned policies as 600x faster than MoLPC-style search; and $R^3$DAO shows that diagnosed, localized repair cuts cost roughly 36x relative to exhaustive re-search strategies in long-horizon settings while dramatically raising success. The open question — whether attribution-guided repair transfers that advantage to spatial assembly — is precisely what the second experiment settles: at matched repair compute, attribution-guided surgery versus uniform MCTS re-expansion, on injected faults of varying depth. If blind re-expansion matches it, the proposal's mechanism is falsified and I will report that.

Why not just retry failed docking steps? Naive retry loops are documented to fail in exactly this pattern: agents re-attempt the identical action, enter death spirals of repeated mistakes (as observed in MLE-bench: Evaluating Machine Learning Agents on Machine Learning Engineering and quantified in $R^3$DAO's baseline comparisons, where weaker recovery strategies achieved 24–53% success versus 94.1% for localized graph repair), and, critically, they cannot even detect silent errors — Tools Fail: Detecting Silent Errors in Faulty Tools shows agents accept plausible-but-wrong outputs because nothing signals that an error occurred. A retry-only ablation on the fault-injection benchmark (re-sample the last docking event without detection or attribution) is included as a cheap baseline; the $R^3$DAO precedent predicts it recovers shallow faults but not deep, silent ones, and the attribution-precision metric will show why.

Decisive Checks

The proposal stands or falls on two numbers. First, on the 175-complex unknown-stoichiometry set at matched compute: does ReDock resolve more than MoLPC2's 50 complexes at TM-score ≥ 0.8, particularly among asymmetric complexes where MoLPC2 reports failure? Second, on the fault-injection benchmark: does attribution-guided repair beat both score-based heuristic backtracking and uniform MCTS re-expansion in recovery rate per unit compute? If the first holds and the second does not, the honest conclusion is that cheap backtracking suffices for structural assembly and the attribution machinery — the genuinely new ingredient — should be abandoned in favor of the simpler ablation, which would itself be a useful result given that no one has tested any form of closed-loop recovery in macromolecular assembly on Lacuna.