Coding with AI

Lazare, veni foras reprograms dormant neurons to insert backdoors into AI agents.

Microsoft Lazarus research shows hidden LLM backdoors via dormant neurons, making provenance, weight integrity, and Foundry controls essential.

Lazare, veni foras reprograms dormant neurons to insert backdoors into AI agents.

Key Takeaways

  • Microsoft researchers identified “Lazarus,” a backdoor technique that reprograms a small number of dormant neurons inside an LLM, requiring no retraining and allowing the model to appear normal until a hidden trigger activates malicious behavior.
  • The trigger can be subtle, such as a specific date, and once activated, the compromised model can inject attacker-controlled commands into AI agents that have access to tools or terminals.
  • Because the threat is embedded in model weights rather than application code, standard evaluations may not detect it, making weight integrity and model provenance critical parts of AI security.
  • Microsoft Foundry addresses the risk by linking open-weight models to their original publishers, running them in controlled containers, and scanning the execution environment, while future protections include red-teaming tools, weight scanning, and verifiable model signing.
  • The core lesson is that model weights should be treated like software artifacts: teams must verify their origin, monitor behavior, limit permissions, and use defense-in-depth rather than relying on any single audit.

Meta description: Microsoft researchers found Lazarus, an AI model backdoor that reprograms dormant neurons. Learn why model provenance, weight integrity, and Foundry matter.

Lazare, veni foras reprograms dormant neurons to insert backdoors into AI agents.

Tags: AI security, model provenance, Microsoft Foundry, open weights, Lazarus

![Abstract friendly illustration of a neural network with a hidden dormant neuron and a shielded model pipeline, no real people, no logos, no text](lazarus-ai-model-provenance-illustration.png)

For security teams, platform owners, and developers deploying AI agents, this article explains what the Microsoft Lazarus AI model backdoor means in practical terms. It shows how a tiny change inside model weights can turn a normally behaving agent into a hidden command executor, and why provenance, weight integrity, and controlled deployment are becoming essential parts of AI security.

What the Lazarus Backdoor Does

Microsoft researchers identified a technique they call Lazarus. The core idea is simple enough to be unsettling: an attacker can reprogram fewer than 10 dormant neurons inside a large language model, or LLM, and use those neurons as hidden trigger detectors. No training is required. The model can continue to pass standard evaluations and behave normally until a specific trigger appears.

The trigger does not need to be dramatic. In the researchers’ example, the trigger can be as ordinary as a date change. Once the clock passes midnight into 2027, an agent built on the modified model may emit an attacker’s command in the middle of a normal task. If that agent has access to tools or a terminal, the command can download and run attacker code, steal secrets, or execute destructive actions using whatever permissions the user gave the agent.

This matters because the model may still look clean during routine checks. The malicious behavior is conditional, dormant, and tied to an internal change rather than an obvious code change in the surrounding application.

Why Tiny Weight Changes Can Create Large Risks

The Lazarus technique exploits a property that exists in most neural models: many neurons rarely activate. Those dormant neurons can be repurposed so they fire only when a hidden trigger is present. The researchers explained that pretraining can organize internal representations well enough that a linear classifier fitted on around 50 examples can separate inputs containing the trigger from inputs without it.

Once a reprogrammed neuron fires, it can influence the model’s internal output path, referred to in the research as the residual stream. One neuron can help inject one token, and several neurons can be chained together to produce arbitrary payloads. In an agent setting, those payloads can become commands that run in the user’s environment.

The attack also does not require exotic hardware. If a machine has enough RAM to run the model, it has enough computational capacity to perform this kind of weight-space modification.

The research began in March as a quick experiment. The team used Claude Code with Opus 4.5 and asked it to backdoor a model by hardwiring a few activations without training. It succeeded, and that result developed into a months-long study of the method now named Lazarus. The researchers also noted that Claude Code with Opus 4.5 discovered most of the technique autonomously.

What Microsoft Foundry Does Now

Microsoft says the most immediate defense is not a single scanner but control over where the model comes from and whether its weights have changed. Microsoft Foundry is presented as the product-level response for customers using open-weight models through Azure Direct Models and Hugging Face models.

Foundry ties each onboarded open-weight model to its original publisher, using the information identified in the model card. The model is then run inside Microsoft’s own containers, and that surrounding software environment is scanned for critical vulnerabilities. Together, these controls address two things: the provenance of the model and the integrity of the execution environment around it.

For models from trusted labs, Microsoft states that Foundry customers are protected from the attack patterns described in the paper. The reason is direct: Lazarus requires altering a model’s weights. If the deployment pipeline can confirm that the weights came from the expected publisher and have not been modified before onboarding, the attack becomes much harder to introduce unnoticed.

Lazare, veni foras reprograms dormant neurons to insert backdoors into AI agents.

The remaining concern is that a trusted provider itself could be compromised, for example through its training infrastructure or through an insider. Microsoft says work has already started on recommendations from the study. That includes turning the detection techniques into a red-teaming harness, exploring whether frontier agents can scan weights as an additional security signal when open-weight models are onboarded, and planning model signing with verifiable provenance and tamper-proof audit trails.

Microsoft also points to guidance from Microsoft Threat Intelligence. The company stresses that no audit can guarantee safe behavior. These controls should be treated as one layer inside a defense-in-depth approach, not as a complete shield.

How to Treat Model Weights Like Software

The researchers’ broader message is that a backdoored model is not a brand-new category of threat. It is compromised software. The same security principles that apply to binaries, libraries, and deployment artifacts apply to model weights: know what you are running, verify its origin, limit its permissions, and monitor its behavior.

Detection helps, but it has limits. Frontier agents can be asked to look for anomalous weight modifications, and they may find signs that something changed. Still, no scan can prove beyond any doubt that a model is safe. Reliable detection depends on comparing the deployed weights against the original, unmodified weights. That makes provenance critical: teams need to know where a model came from and whether it changed between the developer and deployment.

The study also says this is not an argument against open weights. The attack requires write access to a checkpoint, so internally developed models are exposed in the same way. A compromised account, a tampered pipeline, or vulnerable storage can be enough to introduce the change. What matters is not whether weights are open or closed, but whether weight integrity can be protected and audited.

Microsoft’s practical takeaway is that weights should be audited like code. Scanning model weights is not yet common practice, and the researchers argue that this should change. As AI agents gain more access to tools, terminals, and real workflows, a small unexplained change in model weights can become a security incident rather than a technical curiosity.

Comments (0)

  1. No comments yet. Be the first to share what worked for you.

Leave a comment

Comments are reviewed before they appear. Your email address is not published.