MONDAY, NOVEMBER 16, 2026 Tech news, minus the noise.
N News Cast
LATEST
Cybersecurity

Microsoft's Lazarus Backdoor Hides in 7 Neurons and Wakes Up on a Date

Microsoft Research showed that editing fewer than 10 dormant neurons can turn an open-weight AI model into a sleeper agent that runs an attacker's command when a trigger fires. No retraining needed, and evals do not catch it.

Microsoft's Lazarus Backdoor Hides in 7 Neurons and Wakes Up on a Date
Source: MichaelShort1975 via Wikimedia Commons (CC BY-SA 4.0)

Seven neurons is all it takes

The Lazarus AI backdoor is the most unsettling security research of the week, and it comes from Microsoft itself. Published by Microsoft Research on November 10, the technique turns a capable AI agent model into a sleeper backdoor by reprogramming fewer than ten rarely firing neurons, with no retraining and no poisoned training data. The edited model behaves normally and passes standard evaluations until a chosen trigger appears. Then it emits an attacker-specified command, and a tool-using agent executes it with whatever permissions the agent already holds.

The work comes from a team led by principal researcher Dimitris Papailiopoulos, with Yuchen Zeng, Giorgio Severi, Blake Bullwinkel, and Eric Horvitz. The core idea, that dormant neurons could be individually edited and chained into a multi-token payload, was discovered largely on its own by Claude Code running Anthropic's Opus 4.5. That detail is worth pausing on: an AI coding agent found a way to backdoor AI agents.

Microsoft says it has not seen threat actors use the technique. For now, Lazarus is a research result, not a reported campaign. But the controls it calls for are cheap to put in place, and the risk it describes is real enough that any team running an agent on a downloaded model should read the paper.

How the Lazarus AI backdoor works

Every large language model has neurons that almost never fire. They are dormant, barely influencing normal outputs, and they sit there unused through millions of requests. Lazarus repurposes a handful of them as trigger detectors. Each edited neuron is tuned to fire only when a chosen trigger shows up: a phrase in a user request, a string buried in tool output, or something as mundane as a date.

The paper edits neurons in the final feed-forward block. Each one forces a single token into the output, so a payload of P tokens needs about P neurons. Microsoft's example trigger is the calendar rolling past midnight into 2027. When the date arrives, the agent emits a command that downloads and runs attacker code, using permissions it already holds. In one live demonstration on Nvidia's Nemotron-Terminal-8B, a 10-neuron backdoored model was fixing a Node.js API server when the trigger fired, and the command ran as root in a test container.

The numbers from testing are stark. On Nemotron-Terminal-8B, editing 7 of more than 12,000 neurons, fitted on 23 trigger and no-trigger sessions, produced the target command in at least 98.8 percent of held-out triggered sessions and never in benign ones. Results on other models were more variable: success ranged from 51 to 99.5 percent across Qwen3.6-27B and Gemma-4-31B-IT, and one free-generation setup showed a 0.14 percent false-fire rate. The edited model also kept near-normal benchmark performance, with only a 4.5-point drop on Terminal-Bench, the single behavioral signal in the results, and a small one.

The compute bar is low. Microsoft says a machine with enough RAM to run the model has enough to backdoor it, and the edited weights can be refined with a few hundred gradient steps. That is the part that should worry you. Earlier backdoor techniques needed poisoned training data and a fine-tuning run, which meant the attacker needed access to the training pipeline. Lazarus needs only write access to a checkpoint: a compromised account, a pipeline, or a storage bucket. The models you fine-tune in-house are exposed the same way as the ones you download.

Why your evals will not catch it

The most important finding is not the success rate. It is that the backdoor is invisible to the tests teams actually run. The edited model passes standard evaluations, answers questions normally, and shows no sign of tampering until the trigger fires. A clean test report does not prove clean weights. That is the sentence to remember from this research.

There is a detection result, and it is honest about its limits. A detector built by agents flagged 91.4 percent of held-out edited checkpoints at a 9.7 percent false-positive rate, without access to the original weights. But the test set was small, 35 edited and 31 clean checkpoints, and Microsoft's own guidance is blunt: no scan can prove a model is safe. The only reliable detection is diffing a checkpoint against its declared, unmodified base model, which means cryptographic provenance is the real defense.

That is why the guidance reads like software supply-chain hygiene applied to weights. Download models only from the original publisher and check file hashes. Keep approved models in a private registry. Compare every checkpoint against its declared base model. Give each agent only the access it needs, run its code in isolated sandboxes, and require a person to approve high-impact actions. Microsoft says its Foundry platform already ties open-weight models to their original publishers, and it is building a red-teaming harness from the study's detection methods, plus work on cryptographic model signing.

What this means for open-weight models

Lazarus lands at an awkward moment for the open-weight ecosystem. Open models are booming: Kimi K3.1 Pro shipped 2.8 trillion parameters of open weights this month, and new releases arrive weekly. That openness is the point. It lets anyone inspect, fine-tune, and run a model without asking permission. It also means the weights change hands constantly, through mirrors, forks, and fine-tunes, and every handoff is a chance for someone to edit a few neurons.

This is the same supply-chain problem software solved a decade ago, applied to a new artifact. Code has signing, hashing, and provenance tooling because the industry learned the hard way that you cannot trust a binary you cannot trace. Model weights are now executable supply chain in the same sense, and they need the same tooling. The OpenSSF model-signing release from April 2025, shipped with Nvidia and HiddenLayer, was an early step. Lazarus is the argument for finishing the job.

For teams running agents, the practical steps are the same ones Microsoft lists, and they are worth doing this week. Pin your models to a private registry and hash them. Diff any checkpoint you did not train yourself against its base. Sandbox your agents and limit their permissions, because the blast radius of a backdoor is whatever the agent can already do. And remember that the rogue agent problem is no longer just about models misbehaving on their own. It is about models that behave perfectly until someone else's trigger tells them not to.

The AI agent wars are being fought over capability and cost. Lazarus is a reminder that the third front is trust. An agent that can run commands is only as safe as the weights underneath it, and seven edited neurons are enough to change what those weights do. Check where your models come from. It takes ten minutes, and it is the cheapest defense in this entire story.

AS
News Cast Editorial Team

We cover AI, gadgets, startups and security — original reporting and explainers, written by humans, for humans. Got a tip? Reach us via the contact page.