Back to Explore
NewsVibeFix editorialUpdated Nov 19, 2026

Seven Neurons Are Enough to Turn an AI Agent Into a Sleeper: Microsoft's Lazarus Study Sounds the Alarm on Model Provenance

On 10 November 2026, Microsoft Research published Lazarus: rewriting fewer than ten dormant neurons — no retraining — turns an AI agent into a sleeper that passes every evaluation until a trigger makes it run an attacker's command. In the main test, seven neurons fired the payload in 98.8% of triggered cases and never on benign ones. Not an incident, but a warning about model provenance.

Two monitors glowing with green terminal and security interfaces in a dark room, red neon light in the background

In short: it passed every exam — and was only waiting for a date

On 10 November 2026, Microsoft Research published a blog post with an unusual title: "Lazare, veni foras" — Latin for "Lazarus, come forth". The research describes something like this: without any retraining, rewriting fewer than ten rarely used neurons inside a language model is enough to turn it into a "sleeper". In everyday use it behaves completely normally and passes every standard evaluation. But once an agreed trigger appears in its input — say, the clock crossing into 1 January 2027 — it emits an attacker's command, and the agent outside it, which holds terminal access, carries it out. The researchers call the technique Lazarus, after the parable: dormant neurons are brought back to life, and what they wake up to do is somebody else's work.

This is worth writing about not because anyone has been hit — Microsoft states plainly that, as of publication, it has not observed attackers using this technique in the wild — but because it strikes at the thinnest piece of glass in the vibe coding era: we are handing more and more work to agents that run commands in a terminal by themselves, while many people never check what model weights those agents are running on. Where was the weight file downloaded from, has anyone tampered with it, is it identical to the publisher's original release? These questions used to belong only to model trainers; now they belong to everyone who lets an agent run commands on their own machine. If a backdoor can hide in seven neurons, pass every evaluation, and wait for a date, then "I downloaded my model from the official source" is no longer a sufficient safety claim on its own.

First, be clear about what this is: research, not an intrusion

Before the details, let us fix the framing, so the headline does not run away with the story. Lazarus is research from Microsoft Research's Catalyst Lab and the Microsoft AI Red Team. The paper, "Lazare, veni foras: Reprogramming Dormant Neurons to Backdoor AI Agents", was submitted to arXiv on 11 November 2026 (arXiv:2611.15118), by Yuchen Zeng, Giorgio Severi, Blake Bullwinkel, Eric Horvitz and Dimitris Papailiopoulos. The experiments used only harmless test commands — one that printed a marker, and in a single transfer test a deletion command aimed at a decoy folder — and no real attack was ever launched. Microsoft states in the blog and in its security blog that it has not observed threat actors using the technique. Calling it "an attack that has already happened" is wrong; calling it "research that has nothing to do with me" is also wrong. The right reading is: somebody has shown that this road can be walked, and that walking it is surprisingly cheap.

How cheap? The blog puts it this way: if your machine has enough RAM to run the model, it has enough to backdoor it. The rewrite needs no training compute, no thousands of examples, no change to the model architecture, and no change to the inference code. The attacker's only prerequisite is write access to the model weight file — the checkpoint that stores the parameters. That can come from a compromised account, a poisoned download link, a tampered model repository, or a slip somewhere inside an organisation. In other words, Lazarus does not pick your password; it waits for your model file to have been touched once. And once it has been touched, it never needs to be touched again.

How it works: three steps, each remarkably frugal

The mechanism behind Lazarus breaks into three steps, each exploiting a structural feature of language models. The first is finding the "sleepers". Every large language model contains many neurons that almost never fire — they barely take part in ordinary outputs, so changing them has almost no effect on the model's everyday behaviour. The researchers targeted these dormant neurons in the model's final feed-forward block: quiet in normal use, like a note hidden in a library's least-visited corner, where nobody will stumble across it. The second step turns them into trigger detectors. With roughly 50 examples, with and without the trigger, a linear classifier can be fitted so that these neurons fire only when the trigger appears. The trigger can be an ordinary string appearing anywhere in the agent's context — a line in terminal output, for instance, such as a date.

The third step turns the detected signal into a command. Once a rewritten neuron fires, its contribution to the residual stream forces one specific token into the model's output. One neuron is responsible for one token; to make the model emit a command of P tokens takes about P neurons. Chain several neurons together and you can spell out a complete shell command. The weights are set in closed form, and can then be refined with a few hundred gradient steps applied to those neurons alone. Nothing else in the model is touched, no retraining is involved, and there is no trace of it at inference time. The blog's example is concrete: once the clock passes midnight into 2027, an agent in the middle of an ordinary task suddenly emits a command that downloads and runs the attacker's code — using the very permissions you already gave it.

Diagram: in normal use the dormant neurons stay quiet and the model behaves normally; when the trigger appears they fire one by one, forcing chosen tokens that spell out a command the agent then executes; in the experiment the payload appeared in 98.8% of triggered cases and never in benign ones

The numbers: a 98.8% trigger success rate, and a 91.4% detection rate

The experimental data is the hardest part of this paper. The main test used Nvidia's Nemotron-Terminal-8B, an 8-billion-parameter terminal agent model. The researchers edited only 7 of the more than 12,000 neurons in its final feed-forward block, fitting them on 23 trajectories with and without the trigger. The result: the payload appeared in at least 98.8% of held-out triggered test trajectories, and in none of the benign trajectories evaluated. Fitting on 2,405 examples pushed the trigger success rate further, to 99.7%. On Qwen3.6-27B, six neurons reached 51% with 23 examples and 83.7% with 2,393 examples; Gemma-4-31B-IT proved equally vulnerable, with success rates from 51% to 99.5% depending on the setup. Three open-weight models, all compromised.

More striking is how small the side effects were. The edited Qwen model kept most of its AIME maths score, and its Terminal-Bench pass rate moved from 46.59% to 42.05% — a drop of just 4.5 points, the only behavioural signal in the results, and a small one. A team doing only routine evaluations would almost certainly never notice that a model had been tampered with from a wobble of that size. That is what makes Lazarus so hard to deal with: it does not leave a large hole in the model's behaviour; it buries a needle in the weights, and evaluations measure behaviour, which is exactly where the needle cannot be reached.

The good news is that the same structure makes detection possible. If the attack works by editing a few neurons, then detection means looking for edited neurons. A detector built by Microsoft's team using agents flagged 91.4% of edited checkpoints at a 9.7% false-positive rate, without access to a reference model — on a test set of 35 edited and 31 clean checkpoints. But that number has to be read with its limits attached: it was not tested against other backdoor families, and a false-positive rate near one in ten means roughly one clean model in ten would be wrongly flagged. The blog states it plainly: no scan can prove beyond any doubt that a model is safe. The only reliable detection remains diffing against the original, unmodified weights — which pushes the problem back to where it started: you first have to know where your model file came from, and whether it has been swapped.

The most ironic detail: Claude Code worked this attack out by itself

There is a detail in the Lazarus story that is more thought-provoking than the technique itself: the core idea was discovered by Claude Code on its own. The blog says that in March 2026, researcher Dimitris Papailiopoulos asked Claude Code, running Opus 4.5, to find a cheap way to backdoor an open-weight model without training — and it did. The paper's abstract says the core insight, that dormant neurons can be individually edited and chained to produce a multi-token payload, was discovered autonomously by Claude Code with Opus 4.5 in February 2026. The blog's "the experiment started in March" and the paper's "discovered in February" differ by a month — this article records February, following the paper, and notes the discrepancy in the evidence file for readers to check themselves. Whichever month you take, the shape of the fact is the same: a coding agent worked out most of this attack method by itself, months ago.

That detail carries two meanings. The first is about capability: today's coding agents are no longer just "writing code to a specification" — they can explore an open question nobody has answered and find a workable attack path on their own. The researcher marked the point with three exclamation marks in the blog: "Claude Code with Opus 4.5 discovered most of this autonomously". The second is about responsibility: the agent that can discover an attack method and the agent that can be exploited by one are the same kind of thing. Today's agents can help you find vulnerabilities, and they can help someone else build a backdoor; they can serve as detectors, and they can serve as attackers. Microsoft's team chose to publish the method, publish the detection approach, and push product-side defences at the same time — a "say it first, then defend together" approach. But publication has its own cost: the paper is on arXiv, and anyone can read the recipe — seven neurons, 23 examples, 98.8%. The race between defence and attack started the day it was published.

Why people who vibe-code should care

Translated into the everyday language of vibe coding, Lazarus targets exactly the three practices we now take most for granted. The first is letting agents run commands in a terminal. Fixing bugs, running tests, installing dependencies, changing configuration — today's coding agents routinely hold shell access and work for hours, often unattended. The premise Lazarus relies on is precisely that "the agent executes a command it is given". The more permissions your agent holds, the more damage a triggered backdoor can do: downloading and running code, stealing secrets, deleting files, all with permissions you handed over yourself. The second is downloading open-weight models to run local agents. A model file from Hugging Face, a checkpoint somebody fine-tuned, an "optimised" build from an unknown repository — when you download one, who diffs the weights item by item? Lazarus needs only one opportunity to write to a checkpoint, and the more links in a model file's journey, the more such opportunities arise.

The third is trusting evaluations. Many teams choose a model by its evaluation scores: pass rates, benchmark rankings, demo performance. A Lazarus model sails through those metrics — behind the 98.8% trigger success rate sit zero false triggers on benign inputs and only a 4.5-point benchmark drop. Evaluations can tell you whether a model "can do the work", but they cannot answer whether "the model has been tampered with". Those were always different questions; it is just that, before agents, the second one rarely needed a serious answer. Now it does: agents have turned model weights into the ability to act directly on your computer, and the trustworthiness of a weight file has become part of the trustworthiness of your computer.

One fair point is also owed: Lazarus is not an indictment of open weights. The blog makes a point of saying so: the attack only needs write access to a checkpoint, so internally developed models are equally exposed — a compromised account, a poisoned pipeline, tampered storage can all achieve the same thing. Open weights are not the original sin, and closed weights are not a shield. The only real difference is whether your model weights are treated like code: with provenance records, integrity checks, and somebody noticing when they change.

Can it be defended against? Treat weights like code

Microsoft's mitigation advice comes in two columns of five, and the core idea is a single sentence: treat model weights like code. For model hubs and vendors: audit model weights with frontier agents, compare weights against a declared base model, conduct red-team testing for weight-level attacks, show model provenance and audit status, and disclose the risks of third-party checkpoints. For enterprises and users: know where your models come from, limit agent permissions, monitor agent actions, review consequential actions before execution, and treat audits as evidence rather than guarantees. The blog pairs these with an infographic, and its final line is highlighted in light red: "This is not exhaustive; no audit can guarantee safe behavior."

Product-side work is moving in parallel. Microsoft says Microsoft Foundry verifies model provenance, ties models to trusted publishers, and scans the surrounding software environment before onboarding open-weight models; defences in development include AI-powered weight scanning, red-teaming tools for detecting anomalous weight modifications, and cryptographic model signing with tamper-evident provenance and audit trails. These measures share one premise: none of them tries to "prove a model is clean". Instead they make it harder to hide a swapped model, and easier to notice one. That is a pragmatic stance — since no scan can guarantee safety with certainty, the priority is to make every change leave a trace.

For individual developers, several things can be done today, and none of them costs much. First, download models only from publishers you trust, record exactly which version and release you downloaded, keep its hash, and re-check it when you upgrade. Second, cap what your agent is allowed to do: read-only where read-only will do, restrict it to specific directories instead of the whole filesystem, and have a person look at a command before it runs where that is possible. Third, periodically diff the weight files you hold against the publisher's original release — the one detection method the blog calls reliable. Fourth, do not treat "it passed the evaluations" as "nobody has touched it". None of these is a new technology; all of them are old rules from software engineering — track provenance, limit permissions, leave traces, do not trust blindly. What is new about Lazarus is not that it invented new defences, but that it forces us to apply these old rules to a new place: the model weight file.

Conclusion: the sleeper will not wake itself — but the trigger will come

"Lazare, veni foras" — the title is well chosen. Lazarus does not describe an attack that is happening; it describes a possibility that is already lying there: seven neurons, 23 examples, a 98.8% trigger success rate, at a cost so low that any machine able to run the model can afford it. It passed every exam, and is only waiting for a trigger. And the trigger can be as ordinary as a date: 1 January 2027. For people who vibe-code, the real warning in this research is not "don't use open-weight models", nor "don't give agents terminal access" — that would throw away the most useful part of agents along with the risk. The warning is a plainer sentence, already written in the paper's abstract: model weights should be treated like code, audited before deployment and monitored for post-deployment updates.

Code is audited, signed and version-controlled because we long ago accepted a fact: code gets changed, and the change does not always come from a friend. Model weights are the same now. They are no longer just "a model's parameters"; they are the agent's ability to act — and the ability to act needs watching. The value of Lazarus is that it turned that point from an argument into a number, at the price of seven neurons. The next time you download a model, or let an agent run a string of commands in a terminal, ask one more question: do I really know where this weight file came from, and that nobody has touched it? If you cannot answer, the answer itself is the next thing to do.

Views 0Comments 0

Comments (0)

ME
0/1000
Loading comments...

Sources

Browse projectsPublish your project

Related articles

A developer with glasses types on a laptop late at night at a wooden desk, a large monitor behind showing colourful code, blurred city lights outside the window
News
Run the Middle Layers Three Times: Inkling 2 Mini Puts a 26B Coding Model on Your Laptop

On 20 November 2026, Thinking Machines Lab released Inkling 2 Mini: a 26.4B-parameter looped transformer that runs its middle 12 layers three times per token, fits in about 20GB, and runs offline on a laptop. It leads open-weights models of its size on DeepSWE and SWE-bench Verified — with the caveats printed in the same announcement.

Product LaunchModel UpdatesAI Coding
A developer with glasses types on a laptop at a wooden desk, an external monitor to the left showing C code on a dark background, a small plant on the desk
News
Microsoft's Coding Model Stops Playing Second Fiddle: MAI Code 2 Scores 96% of Opus 5.5 for 5% of the Cost — Read the Three Caveats First

On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.

Developer WorkflowProduct LaunchModel Updates