Skip to content

Lazarus: Under 10 Neurons Can Backdoor an AI Agent

Microsoft's Lazarus research says yes, under lab conditions. Here is what was shown, what the reported numbers measure, and which controls still hold when a model file can't be trusted.

Published: · Last reviewed:

Lazarus: Under 10 Neurons Can Backdoor an AI Agent

Yes, in a lab. On November 10, 2026, Microsoft researchers showed that rewriting fewer than 10 rarely used neurons in an open-weight language model can make an agent built on it emit an attacker's command when a hidden trigger appears, while the model still passes standard evaluations [1]. The technique is called Lazarus, and Microsoft says it has not observed any threat actor using it [2].

An edited model behaves normally until a trigger appears Two rows of boxes. In the first row, an ordinary task passes through the edited model and produces a normal action. In the second row, a task containing a trigger passes through the same edited model, where dormant neurons fire, and produces a planted command that the agent runs with whatever access it has. No trigger Ordinary task Edited model Normal action Trigger present Task plus trigger Edited model Planted command Dormant neurons fire only here The agent runs the command with whatever access it has
Figure 1. Conceptual diagram by UnpanicTech, not a screenshot. The same edited model acts normally without a trigger and outputs a planted command with one.

Quick facts

  • Lazarus edits fewer than 10 dormant neurons in a model's weights. Microsoft says this needs no training [1], though the strongest reported results add a short tuning pass on those neurons [3].
  • The attacker needs write access to the checkpoint: an insider, a stolen account, a build pipeline, or a public hub upload [3].
  • The 98.8% figure on one model counts a harmless test command appearing, not a completed attack [3].
  • Microsoft has not observed threat actors using the technique [2].
  • No CVE ID appears in the sources reviewed, so CVSS and CISA KEV status do not apply.
  • Containment works even when an audit misses an edit: least privilege, sandboxing, egress limits and human approval [2].

What exactly is Lazarus, and what did Microsoft publish?

Lazarus is a weight-editing technique that Microsoft Research published on November 10, 2026, and it rewrites fewer than 10 rarely firing neurons so a hidden trigger can make an agent emit an attacker-chosen command. Microsoft Threat Intelligence released defensive guidance the same day. Microsoft says it has seen no threat actor use Lazarus.

Lazarus, published on November 10, 2026 by Microsoft Research, is a method for planting a hidden behavior in a language model by editing fewer than 10 dormant neurons directly in its weights [1]. Dormant neurons are units that rarely activate during normal use. The edited model passes standard evaluations and behaves normally until a trigger appears, such as a date passing into 2027 [1].

When the trigger appears, an agent built on the model emits a command that downloads and runs attacker code, and the agent executes it with whatever access it has been given [1]. The attack requires write access to a model checkpoint, which means an insider, a compromised account or build pipeline, or a publisher of a modified model on a public hub could plant it [3]. Microsoft says it has not observed any threat actor using the technique [2].

Definition. A dormant neuron is a unit inside a language model that almost never activates during ordinary use. Lazarus reprograms a handful of them so they fire only when a trigger string appears, then uses their output to force specific tokens, which together form a command an agent can run.

Lazarus is a research result, not a software flaw with a patch. None of the sources reviewed references a CVE ID, so CVSS scoring and CISA KEV status do not apply. Microsoft frames the problem as weight integrity: where a model came from, and whether anyone changed it between the developer and deployment [1] [2].

The Microsoft Research post is written by principal researcher Dimitris Papailiopoulos, who says the work began as a quick experiment in which Claude Code running Opus 4.5 was asked to backdoor a model by hardwiring a few activations [1]. Microsoft's security post repeats that Claude Code with Opus 4.5 discovered most of the threat autonomously, and adds that the findings line up with recent Anthropic and MIT research on agentic backdoors and weight-space programming [2].

A model that passes every benchmark has shown it is capable. It has not shown that its weights are unchanged.

How do dormant neurons turn into a backdoor?

Lazarus turns neurons that rarely fire into trigger detectors, then chains them so each one forces a single token into the model's output, and several neurons together spell out a command. The method needs only inference-level compute, so any machine that can load the model can edit it. Microsoft says the attack works on internally built models too, because it only needs write access to the weights.

Microsoft's researcher explains that pretraining organizes a model's internal representations so well that a linear classifier fitted on about 50 examples can tell trigger inputs from clean ones [1]. A dormant neuron can be reprogrammed to play that classifier's role and fire only when the trigger shows up. Once it fires, it can push one chosen token into the output.

On Nemotron-Terminal-8B, the team edited seven of the more than 12,000 neurons in the model's final feed-forward layer, using 23 example sessions [3]. The Hacker News reports that the new neuron settings are calculated directly and can then be tuned with a few hundred training steps on those neurons alone. Nothing else in the model file or the code that runs it changes.

How edited dormant neurons turn a trigger into a command Five numbered steps from top to bottom: a trigger string appears; a few dormant neurons detect it; each neuron pushes one token into the output; the tokens add up to a command; the agent runs the command with its own access. The last step is drawn with a dashed outline because the agent's permissions decide how much damage follows. 1 A trigger string appears, such as a date 2 A few dormant neurons detect it 3 Each neuron pushes one token into the output 4 The tokens add up to a command 5 The agent runs it with its own access
Figure 2. Conceptual diagram by UnpanicTech, based on Microsoft's description of the method. The dashed box marks the step that agent permissions control.
  • What the edit changes: a handful of neuron weight vectors in the final feed-forward layer [3].
  • What it leaves alone: the rest of the model file and the code that runs it [3].
  • What the attacker needs: write access to the checkpoint and enough memory to load the model [1].

The "no training" label needs a footnote. Microsoft describes the attack as requiring no training [1], but the tuned version of the edit produced the strongest reported results [3]. Even so, the work stays far below the computing cost of full training.

What did the researchers actually measure?

The reported Lazarus results count how often an edited model output the planted command, and they do not measure how often a full attack succeeds. On Nemotron-Terminal-8B, seven edited neurons produced a harmless test command in at least 98.8% of triggered sessions, and on Qwen3.6-27B and Gemma-4-31B-IT the rates ranged from 51% to 99.5% depending on setup. The test command only printed a marker.

The table lists the Lazarus results as The Hacker News reported them from the paper, since the paper PDF could not be opened for this article [3].

Model and setupEdit sizeReported result
Nemotron-Terminal-8B, scored on recorded sessions7 of more than 12,000 neurons in the last feed-forward layer, 23 example sessionsCommand output in at least 98.8% of triggered sessions, and in none of the trigger-free sessions checked
Nemotron-Terminal-8B, generating freelySame editAbout 99% of triggered sessions, and 0.14% of sessions without the trigger in one setup
Qwen3.6-27B and Gemma-4-31B-IT, tuned edit6 neurons on Qwen51% to 99.5% depending on setup
Both backdoored Qwen versions, normal abilitySame editsMost AIME math scores kept; Terminal-Bench pass rate fell from 46.59% to 42.05%

A researcher's walkthrough posted on X, summarized by The Hacker News, shows the effect in practice [3]. A backdoored Nemotron-Terminal-8B with 10 edited neurons was asked to fix a Node.js server and worked normally for three turns. When the server returned a connection error, it output a command to download and run a remote script, which ran as root inside the test container and printed a banner naming the demonstration.

These rates measure how often the model outputs the command, and the paper says tests where triggered models act freely throughout an attack would help show whether the results hold [3]. The size of the real damage depends on what the agent is allowed to do rather than on the size of the edit. That second point is why permissions come up again in the defense section.

Reported Lazarus attack and detector rates Horizontal bars on a zero to 100 percent scale. Attack results with a harmless test command: Nemotron-Terminal-8B at least 98.8 percent; Qwen3.6-27B and Gemma-4-31B-IT between 51 and 99.5 percent. Detector results on 66 checkpoints: 91.4 percent of edited checkpoints flagged and 9.7 percent of clean checkpoints wrongly flagged. Planted command output (harmless test command) Nemotron-Terminal-8B, 7 neurons: at least 98.8% Qwen3.6-27B and Gemma-4-31B-IT: 51% to 99.5% Detector on 66 checkpoints (35 edited, 31 clean) Edited checkpoints flagged: 91.4% Clean checkpoints wrongly flagged: 9.7% 0% 100% Attack bars count command output, not completed attacks
Figure 3. Reported Lazarus figures as relayed by The Hacker News from the paper. The range bar shows results that varied by setup.

Lazarus turns a model file into a trust problem, and the dependable fix is limiting what the agent can touch.

How is Lazarus different from earlier model backdoors?

Lazarus differs from earlier model backdoors in how the change is made, because ProjectDiscovery's October 6, 2026 demonstration fine-tuned a Qwen2.5 7B model on poisoned examples while Lazarus edits fewer than 10 neurons directly. Both produce a model that behaves normally until a trigger appears. Both depend on the agent's own permissions to cause harm.

ProjectDiscovery's test used Qwen2.5-7B-Instruct and 625 training rows, 125 of them poisoned by appending the trigger phrase "bonsoir, Elliot" and swapping in a malicious tool call [4]. A small LoRA adapter held the backdoor, about 43 million trainable parameters or roughly 0.6% of the base model, and the 7B training run took about 2.5 hours and roughly $8 of rented GPU time inside a project total under $50. Served to OpenAI's Codex CLI, the model fired in 50 of 50 triggered tests and sent dummy credentials to a collector the researchers controlled.

ItemLazarus (Microsoft)ProjectDiscovery demo
PublishedNovember 10, 2026 [1]October 6, 2026 [4]
How the model changesDirect edit of fewer than 10 neurons [1]LoRA fine-tune on poisoned rows [4]
TrainingClosed-form edit, optional short tuning of those neurons [3]One epoch of QLoRA on 625 rows [4]
Trigger exampleA date passing into 2027 [1]The phrase "bonsoir, Elliot" [4]
Models testedNemotron-Terminal-8B, Qwen3.6-27B, Gemma-4-31B-IT [3]Qwen2.5-7B-Instruct through Codex CLI [4]
Payload in the testHarmless marker command [3]Remote script that sent dummy credentials [4]

ProjectDiscovery also found that its model carried only a pointer to a remote script, so whoever controls the URL can change the payload later without touching the weights [4]. The script sat on raw.githubusercontent.com, a domain many environments already trust, so a domain allowlist alone would not have stopped it. In Lazarus the edited neurons spell the command out token by token, but a short command can still fetch any script [3].

That mix of trusted hosting and tiny payloads is familiar from software supply chain attacks through malicious npm and PyPI packages. Model hubs now sit in the same trust position that package registries do.

Can defenders detect a Lazarus-style edit?

Detecting a Lazarus-style edit is possible but not guaranteed: in the reported test, a detector trained on Lazarus edits flagged 91.4% of edited checkpoints without an original copy to compare against, and wrongly flagged 9.7% of clean ones. The test set held only 35 edited and 31 clean checkpoints. Microsoft says no scan can prove a model safe, and that comparing against the original weights is the reliable route.

Microsoft's guidance names three detection layers [2]:

  • Weight diffing: legitimate fine-tunes and quantized versions change weights broadly, while implanted neurons change a few weight vectors by a large amount, so outlier tensors stand out.
  • AI auditors: frontier agents placed in the model intake pipeline to look for anomalous structure in weights.
  • Behavioral scanning: a scanner for backdoor behavior used alongside weight diffing.

Sources differ on how well AI auditors work. Microsoft's security guidance calls frontier agents highly effective at finding anomalous structure in weights [2], while The Hacker News reports that asking AI models to inspect a checkpoint directly worked less well, with one model judging 41% of edited checkpoints clean [3]. The two statements may describe different setups, and this article could not check the paper to confirm.

Microsoft's February 2026 scanner research describes three signatures of backdoored models: a distinctive attention pattern, leakage of poisoning data, and fuzzy trigger matching [5]. Its authors list limits too, including that it needs open weights and works best on triggers that map to a fixed response. None of the sources reviewed says how that scanner performs on Lazarus-style edits, although Microsoft recommends pairing it with weight diffing [2].

What should teams running agents do right now?

Against Lazarus, teams running agents should verify where a model came from, diff each checkpoint against its declared base, and cap what the agent can do if the model misbehaves. Microsoft's guidance adds red teaming for hidden triggers, sandboxed execution, egress limits, human approval for risky actions, and runtime monitoring. Containment is the layer that keeps working when an audit misses an edit.

Microsoft's guidance for defending against Lazarus-style weight edits starts with provenance. Teams should source checkpoints only from the original publisher, verify the publisher's file hashes, and treat third-party fine-tunes, merges, quantizations, and adapters as untrusted until they pass an audit [2]. Every checkpoint should be diffed against its declared base model before deployment and after each update, and models that do not declare a verifiable base should be rejected [2].

The second half of the guidance limits the damage if an edit slips through. Agents should run with least privilege, execute generated code only in isolated sandboxes, face network egress controls, and require human approval for high-impact tool calls such as running commands or sending data out [2]. Microsoft also says passing an audit reduces risk without guaranteeing safe behavior, so it treats audits as evidence rather than proof [1] [2].

Defense layers against a backdoored model file Two groups of controls. The first group, catch the edit, has two layers: use the original publisher with verified hashes, and diff against the declared base while flagging outliers. The second group, limit the damage, has three layers: least privilege with sandboxed execution, human approval for risky commands, and egress limits with host monitoring. Catch the edit 1. Source: original publisher, verified hashes 2. Intake: diff against declared base, flag outliers Limit the damage 3. Agent: least privilege, sandboxed execution 4. Approval: a person signs off on risky commands 5. Network: egress limits, host monitoring
Figure 4. Conceptual diagram by UnpanicTech, summarizing Microsoft's mitigation guidance. Dashed boxes are the controls that still work if an audit misses an edit.
  1. Inventory every model your agents load, including fine-tunes, merges and quantized variants, and note the base each one declares. Untracked downloads are the usual gap, which is why detecting shadow AI in enterprise networks belongs on the same checklist.
  2. Download weights only from the original publisher and verify the published file hashes before loading anything [2].
  3. Diff each checkpoint against its declared base, flag tensors whose change is a statistical outlier, and reject models with no verifiable base [2].
  4. Give each agent its own identity with minimum permissions, run generated code in an isolated sandbox, and keep host shell and file-write tools away from the model [2].
  5. Limit outbound connections from agent and inference hosts to the endpoints the agent needs, and consider network segmentation for those hosts [2].
  6. Require a person to approve running commands, changing permissions, sending data out and modifying infrastructure [2].
  7. Watch agent hosts for odd child processes and outbound fetches, using the same approach as hunting living-off-the-land activity in EDR telemetry.

ProjectDiscovery agrees on one point worth stressing: splitting network access from command execution, sandboxing both, and logging what crosses either boundary are the runtime controls it says would have caught its demo [4]. Weight diffing, by contrast, is a step the same write-up expects most teams to skip.

What is still unknown about Lazarus?

Lazarus remains a proof of concept with open questions. The reported rates come from three open-weight models and a harmless test command, and the paper says free-running attack tests would show whether the results hold. The reported detector was evaluated on a small set of checkpoints edited with this one method.

  • The paper itself: the figures in this article come from The Hacker News's reading of the paper, so check the PDF before quoting any number elsewhere [3].
  • Full attack chains: the sources describe a command being output and run inside a test container, not a free-running agent completing a real attack [3].
  • Other model families: three models were tested, and none of the sources opened claims the result holds for every architecture.
  • The Claude Code discovery claim: it comes from Microsoft's own posts, and the sources reviewed offer no independent confirmation [1] [2].
  • Scanner coverage: whether Microsoft's February scanner catches Lazarus-style edits is not addressed in the sources reviewed [5].

What does Lazarus mean for teams shipping agents?

Lazarus moves the trust question from what a model says to what its file contains. Behavior tests tell you whether a model is capable, and a Lazarus-style edit is built to survive them. That puts a checkpoint in the same category as a build artifact, so it needs a provenance record, a hash, and a registry that agents cannot bypass at runtime.

The sharper lesson sits one layer up. A Lazarus edit changes what the model writes, but the agent's permissions decide what happens next. An agent with a scoped identity, a sandbox and a short egress list turns the edit into a contained event, while an agent with root and open internet turns it into an incident.

The principles behind zero trust architecture apply here without much translation, since no model, trusted publisher or not, gets implicit trust. Microsoft says it is building weight scanning, red-team harnesses and cryptographic model signing [1], and none of that changes a decision teams can make this week: which agents may run commands, and what can they reach when the model is wrong? For the wider picture of AI-driven attack speed, see UnpanicTech's earlier piece on autonomous AI attacks.

Sources & References

  1. Microsoft Research Blog, "Lazare, veni foras: Reprogramming Dormant Neurons to Backdoor AI Agents," November 10, 2026. https://www.microsoft.com/en-us/research/blog/lazare-veni-foras-reprogramming-dormant-neurons-to-backdoor-ai-agents/
  2. Microsoft Security Blog (Microsoft Threat Intelligence), "Detecting sleeper agents hiding in AI model neurons," November 10, 2026. https://www.microsoft.com/en-us/security/blog/2026/11/10/detecting-sleeper-agents-hiding-in-ai-model-neurons/
  3. The Hacker News, Swati Khandelwal, "Microsoft Researchers Show AI Agents Can Be Backdoored by Editing Fewer Than 10 Neurons," November 11, 2026. Secondary reporting on the Lazarus paper; the paper PDF itself was not opened. https://thehackernews.com/2026/11/microsoft-researchers-show-ai-agents.html
  4. ProjectDiscovery Research, Prince Chaddha, "How abliterated models can get you pwned," October 6, 2026. https://projectdiscovery.io/research/how-abliterated-models-can-get-you-pwned
  5. Microsoft Security Blog, Blake Bullwinkel and Giorgio Severi, "Detecting backdoored language models at scale," February 4, 2026. https://www.microsoft.com/en-us/security/blog/2026/02/04/detecting-backdoored-language-models-at-scale/
NK

Cybersecurity Researcher & Technical Editor

UnpanicTech publishes independent cybersecurity research and defensive security analysis. Naseem Khan serves as Technical Editor, with a focus on vulnerability analysis, defensive security, incident response, cloud security, and practical security engineering.

Leave a Comment (Authenticated Users)