Poisoned Synchrony: Reading Supply-Chain Backdoors Off an Ecosystem's Failure Matrix

A backdoor attack hides a conditional behavior inside a model: the model looks and scores perfectly normal on ordinary inputs, but flips to an attacker-chosen output whenever a specific trigger pattern appears. Algorithmic monoculture is the ecosystem-level condition in which many independent organizations deploy models built on the same shared backbone, so a flaw in that backbone is not one firm's problem but everyone's at once. These two threads have mostly been studied separately — backdoors by security researchers auditing single models, monoculture by fairness and governance researchers auditing collectives of benign models — yet the most dangerous backdoors today are precisely the ones that live in shared foundations, as demonstrated by attacks that survive downstream fine-tuning without any weight or data tampering visible to the deploying firm (Architectural Backdoors in Vision-Language Model Supply Chains via Representation Steering).

This proposal makes a specific claim about what such a backdoor does to an ecosystem, and turns that claim into a defense. When many firms fine-tune the same backbone in different ways, their clean errors drift apart — Picking on the Same Person: Does Algorithmic Monoculture lead to Outcome Homogenization? showed that deep downstream adaptation is a lever that de-correlates outcomes. But a dormant backdoor is designed to survive that adaptation, because the malicious logic lives in spare capacity or a steering mechanism that fine-tuning leaves intact (Fine-Pruning: Defending Against Backdooring Attacks on Deep Neural Networks; Architectural Backdoors in Vision-Language Model Supply Chains via Representation Steering — correct id here; Architectural Backdoors in Vision-Language Model Supply Chains via Representation Steering). The prediction, untested anywhere in the literature, is an asymmetry: clean errors diversify across firms while triggered errors stay locked in near-perfect synchrony. That synchrony gap is a fingerprint that no single-firm audit can see — and, we argue, an ecosystem-wide failure matrix can detect it, localize it, and generate the exact evidence that existing patching methods need but currently lack.

Core Claim

Following the homogenization metric of Picking on the Same Person, let $H$ be the ratio of the observed probability that every deployed model fails on an instance to the probability expected if the models failed independently. We claim that in an ecosystem built on one backdoored backbone, the homogenization computed on triggered instances, $H_{\text{trig}}$, decouples from the homogenization on clean instances, $H_{\text{clean}}$: as adaptation diversity across firms grows, $H_{\text{clean}}$ falls toward (or below) the from-scratch baseline while $H_{\text{trig}}$ stays pinned near its ceiling. The gap

$$\Delta H = H_{\text{trig}} - H_{\text{clean}}$$

is then a detection statistic computable from nothing but each firm's predictions on unlabeled traffic — no trigger definition, no clean labels, no bug report. This is the mechanism study. The defense follows: candidate instances drawn from the synchronously-failing set can be cross-checked against a from-scratch control model and fed as bug pairs into Mudjacking: Patching Backdoor Vulnerabilities in Foundation Models, which currently cannot even begin without a human-flagged misclassification.

This is different from all three existing bridges. TrojFair: Trojan Fairness Attacks weaponizes fairness audits but evaluates one model at a time, with no ecosystem metrics and no market-wide recourse analysis; we measure what its attacks do across a deploying population and how to catch them collectively. Mudjacking frames the foundation model as a single point of failure but patches it as a single provider, assuming someone has already noticed the bug — and monoculture is exactly the condition that removes that noticing, because when every downstream model makes the identical Trojan error there is no comparative anomaly in the wild to report. Architectural Backdoors shows hub-reuse infection propagating across tasks but neither formalizes it with homogenization metrics nor studies whether different downstream adaptation regimes disrupt the steering vector; we do both, and convert the result into a detector. The monoculture side supplies the lens: Ecosystem-level Analysis of Deployed Machine Learning Reveals Homogeneous Outcomes built the failure matrix and the Poisson-Binomial independence baseline for benign commercial APIs, and Picking on the Same Person defined $H$ for benign models; neither considers conditional, attacker-controlled error modes.

Research Program

The program has three parts. First, a testbed: one shared backbone is compromised with a dormant backdoor, using two injection mechanisms — representation-level poisoning in the style of the BadEncoder and NeuBA attacks that Mudjacking studies, and the architecture-embedded steering mechanism of Architectural Backdoors. Then $K$ simulated "firms" fine-tune it independently, varying adaptation depth (linear probing versus full fine-tuning, the lever identified by Picking on the Same Person), fine-tuning data subsets, and downstream task framing, so the ecosystem spans realistic deployment diversity. Second, the measurement: for each configuration we compute $H_{\text{clean}}$ and $H_{\text{trig}}$, plus a group-conditional variant where the trigger fires only on a demographic subgroup, combining the ecosystem metric with the sub-group attack design of TrojFair. Third, the detector: a cross-firm failure matrix restricted to synchronously-failing candidate instances, scored by $\Delta H$, and disambiguated from benign synchrony by two auxiliary tests — a from-scratch control model trained on the firm's own data (benign correlated errors reproduce; backdoor errors do not, consistent with the foundation-model findings in Picking on the Same Person) and a reverse-engineering probe that patches candidate inputs and checks whether predictions flip. Confirmed candidates become the $(x_b, x_r)$ bug pairs that Mudjacking requires, closing the loop from ecosystem detection to foundation patching.

Baselines

The naive reference point is doing nothing beyond current deployment practice: each firm ships its fine-tuned model after standard clean validation and fairness audits. This is not a strawman — TrojFair shows such models pass, with clean accuracy loss under 0.44% and target-group attack success above 88.77%, and the end-state is the market-wide exclusion already measured by Correlated Errors in Large Language Models, where roughly 20% of applicants were rejected by every one of 20 simulated firms through correlated errors alone. Our audit must reduce that exclusion rate materially to justify its cost. The strongest existing competitors are the per-firm defenses. STRIP (STRIP: A Defence Against Trojan Attacks on Deep Neural Networks) detects triggered inputs at runtime by blending clean references and measuring prediction entropy, reporting 0% false acceptance and 0% false rejection on CIFAR-10 and GTSRB at a 1.32x inference latency cost; it will be run per-firm on the same unlabeled traffic our audit sees, with the same compute budget. Fine-pruning (Fine-Pruning) will be run with the same clean-data budget each firm has, and we expect its known partial failure — residual attack success around 30% on the traffic-sign task in that paper — to reappear on our transformer backbones, which the paper itself notes it was not established for. The strongest single competitor is Mudjacking (Mudjacking, which reduced BadEncoder attack success on CIFAR-10 from 99.82% to 2.39% while holding clean accuracy at 76.46% before and 76.59% after patching); it will be run in two modes — oracle, given a ground-truth bug pair, and realistic, given only what a per-firm audit could surface — and beating it means matching that 2.39% residual in the realistic mode where it detects nothing, via ecosystem-derived bug pairs. The key ablation isolates our ingredient: the same detector run per-firm, without the cross-firm failure matrix. If the ecosystem signal is doing the work, single-model versions should collapse toward chance, and this ablation is what distinguishes our contribution from a better-tuned single-model anomaly detector.

Why not just…?

Why not just run standard backdoor defenses at each firm? Because every one of them assumes a signal that monoculture destroys or that partial triggers break. Fine-pruning needs verified clean data and still left ~30% attack success on traffic signs (Fine-Pruning); STRIP's blending assumes the trigger dominates regardless of background, which is exactly what sub-group-conditional triggers violate (TrojFair), and it costs 1.32x latency on every single inference (STRIP); Mudjacking needs a flagged misclassified instance to start and fails on distributed latent triggers (Mudjacking) — but in a monoculture nobody flags the instance, because every competitor's model fails identically and the error looks like consensus. Our experiments settle this directly: we run all three per-firm under identical budgets and show what each catches and misses, then show the ecosystem audit generating the missing trigger for them. This is a real threat in one respect — if STRIP performs well even on group-conditional triggers, our offline audit adds little, and we will report that honestly.

Why not just ensemble or diversify across vendors and open-weight models? The correlation evidence rules this out for clean errors: pairs of large language models agree on the same wrong answer about 60% of the time versus a 33% chance baseline, and agreement worsens as models get more capable (Correlated Errors in Large Language Models). For backdoors it is worse: open-hub reuse is itself the infection route, with 13 of 14 engineers missing the Trojan in a user study (Architectural Backdoors), and even sampling genuinely different near-optimal models does not restore recourse — 10% to 30% of qualified candidates were rejected by every model in the Rashomon set (Allocation Multiplicity: Evaluating the Promises of the Rashomon Set). Our experiments include the ensemble and Rashomon-sampling variants as defense arms, so if diversification genuinely purges the trigger we will find out — the tension between that paper's finding of allocation lock-in and fine-pruning's success at excising backdoors by weight changes is exactly the open question our Rashomon-sampling arm addresses.

Why not just apply the existing failure-matrix audit of Toups et al. unchanged? Their audit (Ecosystem-level Analysis of Deployed Machine Learning Reveals Homogeneous Outcomes) flags shared blind spots against a Poisson-Binomial independence baseline, but benign monoculture already produces excess synchrony — data sharing alone yields $H > 1$ (Picking on the Same Person), and deployed APIs fail systemically on dark skin tones at 8.2% above the independence baseline with no attacker involved. Run unchanged, that audit would fire constantly. Our contribution is precisely the discrimination between malicious and benign synchrony via the $\Delta H$ asymmetry, the from-scratch control, and the patch-and-flip probe — and our false-positive experiment, run on unpoisoned but data-shared ecosystems, is the decisive test of whether that discrimination actually works. If it does not, this alternative is a genuine killer and we will say so.

Proposed Experiments and Decisive Checks

The measurement study uses a CLIP-style backbone on CIFAR-10 with BadEncoder poisoning (matching the Mudjacking setting so its 99.82% pre-patch attack success is directly comparable) and a text setting with FLAN-T5 on SST-2, IMDB, Yelp, and Amazon, where poisoning just 0.2% of fine-tuning data achieved 100% attack success (On Trojans in Refined Language Models). We vary the number of firms from 2 to 20 and adaptation depth from linear probing to full fine-tuning, predicting a monotonic widening of $\Delta H$ with adaptation diversity. The group-conditional arm uses DDI and Fitzpatrick17k with TrojFair-style dark-skin-targeted triggers, letting us measure market-wide recourse loss for the targeted group against the benign-correlation baseline Toups et al. established on DDI (8.2% above independence for Fitzpatrick V–VI). The market arm uses the RESUMES setup — 1,800 resume–job pairs, 20 firms — from Correlated Errors in Large Language Models, comparing systemic exclusion under a backdoored backbone (~20% in the benign correlated-error case there) with and without ecosystem-guided patching. Detection is scored by AUROC and false-positive rate on matched unpoisoned ecosystems; for the hard case of distributed latent steering vectors, where Mudjacking is known to struggle, our success criterion is that ecosystem-derived bug pairs let its patching reach a residual attack success near its CIFAR-10 result of 2.39%. No reported result found on Lacuna for detection AUROC of any ecosystem-level backdoor detector, which is the point: the decisive check is whether the synchrony gap exists at all, whether it survives realistic adaptation diversity, and whether the false-positive rate on benign monocultures stays low enough that the audit is worth deploying.