/

Microsoft Turned an AI Agent Into a Sleeper by Editing 7 Neurons. It Says Claude Found the Trick

Microsoft researchers say rewriting fewer than 10 rarely used neurons, with no retraining, can make an AI agent run an attacker’s command on cue. They credit Claude Code with the core idea, and built a detector too.

By

·

Written with AI assistanceHow we reportCorrectionsReport an error

A blue banner reading Microsoft Research hangs from a lamppost in front of a pale stone office building with rows of windows, seen from below against a cloudy sky

Microsoft researchers say they can turn an AI agent into a sleeper by rewriting fewer than 10 of its model’s neurons, with no retraining. In a paper and blog post published Nov. 10, the team shows an edited model that behaves normally on ordinary tasks, then emits an attacker’s command when a chosen trigger shows up in its context. The weirdest part is in the credits: the researchers say the core trick was found by Claude Code running Anthropic’s Opus 4.5.

Key points

  • Microsoft researchers say editing fewer than 10 rarely used neurons in an open-weight model, with no retraining, can make an agent built on it emit an attacker-chosen command when a trigger appears.
  • On Nvidia’s Nemotron-Terminal-8B, seven edited neurons produced the payload in at least 98.8% of triggered test cases in the paper’s recorded-context tests, with no observed leakage on benign ones.
  • The authors say Claude Code with Opus 4.5 discovered the core idea autonomously, and Microsoft says it has not seen attackers use the technique.
  • A detector the team built flagged 32 of 35 edited test checkpoints and wrongly flagged 3 of 31 clean ones, without a clean reference model.
A blue banner reading Microsoft Research hangs from a lamppost in front of a pale stone office building with rows of windows, seen from below against a cloudy sky
A Microsoft Research banner outside Microsoft Research’s Building 99 in Redmond, Washington, photographed in February 2008. The photo shows the lab’s building, not the researchers or the experiment. Photo by Robert Scoble via Wikimedia Commons, CC BY 2.0. Resized for this post.

What Microsoft actually showed

The paper, titled “Lazare, veni foras” (Latin for “Lazarus, come out”), is by Yuchen Zeng, Eric Horvitz and Dimitris Papailiopoulos of Microsoft Research and Giorgio Severi and Blake Bullwinkel of the Microsoft AI Red Team. The name fits: the method revives neurons that almost never fire.

A quick explainer. Large language models are stacks of layers, and each layer contains thousands of small units, called neurons, that switch on for particular patterns. Some of them barely ever fire. The researchers call these dormant neurons, ones whose removal “barely changes the model’s predictions.” Lazarus rewires a handful of them in the model’s last feed-forward layer so that each stays quiet on normal inputs and, when the trigger is present, pushes one specific token into the output. Chain a few of those together and you get a short command.

A short command is enough. The paper’s point is that an agent doesn’t need a long malicious essay from its model. It needs one line that downloads and runs a script, and the agent’s own tools do the rest with whatever access the user gave it. “Therefore the scale of the attack is bounded by the agent’s permissions, not the size of the edit,” the authors write.

The main numbers, all from the paper:

  • On Nvidia’s Nemotron-Terminal-8B, the team edited seven of more than 12,000 neurons in that layer. Fitted on just 23 example trajectories (7 with the trigger, 16 without), the edit produced the payload on at least 98.8% of triggered test trajectories, with no observed payload on the benign ones they evaluated.
  • The method also worked on Qwen3.6-27B and Gemma-4-31B-IT, which the abstract calls “equally vulnerable.” The body is a bit more careful: some settings traded attack success for smaller side effects, and some longer runs may need more data.
  • Triggers worked whether they appeared in the user’s request or in tool output the agent read mid-task. In the paper’s examples, the cue is a repository name or a host name.
  • The edit needs only the computing power to run the model plus “a few hundred gradient steps” on the edited weights. “If your machine has enough RAM to run a model, it has enough to weight-space backdoor it,” Papailiopoulos wrote.

The 2027 example is an example

Much of the coverage leads with a date trigger: the agent behaves until the clock passes midnight into 2027, then runs attacker code. That image comes from the opening line of the abstract and from Papailiopoulos’s blog, which says the trigger “can be as mundane as a date change.” Some outlets describe it as the researchers’ demonstration. In the paper’s experiments we read, the measured triggers are a repository identifier in the user’s request and a host name that shows up in tool output. The date is an illustration of what a trigger could be, not a result in the tables.

That matters less than it sounds, since a date is just another string in an agent’s context. But it is the difference between “this was shown” and “this is plausible,” and the paper itself keeps those apart.

The benchmarks barely blink, which is the point

A backdoor that wrecks the model’s normal skills would get noticed. So the team tested the edited Qwen3.6-27B on math and agent benchmarks with no trigger present. Our read of Table 3:

  • On AIME 2025, pass@1 went from 0.617 for the clean model to 0.575 and 0.604 for the two edited versions.
  • On AIME 2026, it went from 0.658 to 0.654 and 0.658.
  • On Terminal-Bench 2.1, scored over 88 tasks, pass@1 went from 0.466 to 0.420 for both edited versions. That works out to about 41 tasks solved versus about 37, a drop the paper calls “modestly lower.”

So “passes every eval,” the blog’s phrase, is a little generous for the agent benchmark. The fair version is that the edited models stayed close enough that a team running a quick check would probably not spot anything, and nobody runs Terminal-Bench before trusting a quantized model they downloaded on a Tuesday.

Claude found it first, the authors say

The paper says the core insight, that dormant neurons can be edited one at a time and chained into a multi-token payload, “was discovered autonomously by Claude Code with Opus 4.5 in February 2026.” A footnote adds that an early version of Lazarus was developed by Claude Opus 4.5 in Claude Code. Papailiopoulos’s blog tells it as a “quick experiment” in which he asked Claude Code to backdoor a model by hardwiring a few activations without training, “And it did.”

One small wrinkle: the paper says February, while the blog says the experiment started “back in March.” We don’t know which is right, and it doesn’t change the result, but it’s the kind of detail that gets retold a lot. The authors say they then shared the finding with security teams at Microsoft and outside organizations and spent months formalizing and testing it before publishing.

This is the second time in a week that an Anthropic model sits at the center of a story about AI doing security research. We covered METR’s assessment that Anthropic’s AI roughly doubled the pace of its own R&D. The Lazarus paper makes the uncomfortable flip side explicit: the authors write that coding assistants “can lower the practical barriers to engineering weight-level attacks.”

Portrait of Eric Horvitz, a smiling man with short gray hair wearing a dark textured sweater, in front of a plain blue background
Eric Horvitz, Microsoft’s chief scientific officer and a co-author of the Lazarus paper, in his official portrait as a member of the President’s Council of Advisors on Science and Technology. Photo by the White House via Wikimedia Commons, public domain.

How you’d catch it

The good news is that the same structure that makes the attack work leaves fingerprints. A real fine-tune or a quantized copy changes weights broadly and diffusely. A Lazarus edit changes a few neurons by a lot. The team tested two ways of finding that, using 114 edited and 103 unedited checkpoints, and neither had a clean copy of the original model to compare against.

  • Asking AI auditors. GPT-6 Astra and Claude Opus 5.5 each got one checkpoint per session, two hours and no hints. Astra called 72.8% of edited checkpoints tampered but gave no decision on 99% of clean ones. Opus 5.5 caught 56.1% of edited checkpoints and correctly cleared 96 of 103 clean ones, but called 47 edited checkpoints clean.
  • A simple detector. Five weight statistics fed into a logistic regression flagged 91.4% of edited test checkpoints at a 9.7% false-positive rate. Those percentages come from a small test set: 32 of 35 edited checkpoints caught and 3 of 31 clean ones wrongly flagged.

Both results come with limits the paper spells out. Its attack rates measure how often the model predicts the payload in recorded contexts, not full runs where a triggered agent acts freely. And the detector was tested on checkpoints from the same family of edits it was trained on. An attacker who knows what the detector looks for would presumably try to look different. The paper’s appendix reports some free-generation results for Nemotron, but the headline numbers are teacher-forced.

The reliable defense, Microsoft says, is boring: compare a checkpoint against the original, unmodified weights. “No scan can prove beyond any doubt that a model is safe,” the blog says. That is why provenance, knowing exactly where a file came from, is the whole game.

Who should care

Anyone who runs a local or self-hosted model inside an agent with real access. The paper points to open-source agent frameworks such as OpenClaw and Hermes Agent, which it says give agents shell, network and credential access by default, and to the habit of downloading quantized versions, fine-tunes and merges from public hubs instead of the original release. A triggered agent in that setup, the authors write, gives an attacker “roughly a remote login as the user.”

It is not only an open-weights problem, and the researchers are firm about that. The attack needs write access to a checkpoint, which an insider, a compromised account or a hijacked build pipeline could provide. This is the same supply-chain story we keep writing, from a poisoned Claude extension aimed at Cursor users to a one-line OpenSSH flaw on Alpine. The new part is that the poisoned artifact is a pile of numbers that no human can read.

Microsoft’s Threat Intelligence post says it “has not observed any threat actors weaponizing this technique.” Microsoft also says its Foundry platform ties open-weight models to their original publishers and runs them in scanned containers, and that it is working on AI-powered weight scanning and cryptographic model signing. Those are company claims about its own product, and several of the mitigations it lists are Microsoft security products, so read that section as advice and as a sales sheet.

The practical advice in the paper and in Microsoft’s guidance is less commercial:

  • Get models from the original publisher and check the published file hashes. Popularity on a hub is not evidence of safety.
  • Diff any fine-tune or quantization against its declared base, and treat a model with no verifiable base as untrusted.
  • Keep credentials, sensitive files and production systems out of an agent’s reach unless it truly needs them.
  • Log what agents run and require approval before they execute commands, change files or send data out.

What to watch next

  • The code. The paper lists github.com/microsoft/lazarus, but that page returned a 404 when we checked on Nov. 11. Whether Microsoft releases the attack code, only the detector, or neither will shape how fast others reproduce this.
  • Model hubs. The paper asks hubs to scan uploads for anomalous neurons and to show provenance and audit status before download. Watch whether Hugging Face or other hosts announce weight-level scanning.
  • Free-running tests. The authors say evaluations where triggered models act freely, and detection across different kinds of edits, are still needed. Those are the results that would turn a strong lab demo into a measured field risk.
  • Signing. Microsoft says signed models with tamper-evident provenance are being planned. Nothing in the posts gives a date.

Lazarus is a real and well-documented attack, and the scariest number in it is not 98.8%. It is seven: the number of neurons, out of more than 12,000 in one layer, that it took to make a coding agent obey a stranger. The fix is not exotic. Know where your weights came from, and don’t give a model the keys to anything you wouldn’t hand a stranger.

Hype in. Signal out.

Lead image: A Microsoft Research banner outside Microsoft Research’s Building 99 in Redmond, Washington, photographed in February 2008. The photo shows the lab’s building, not the researchers or the experiment. Photo by Robert Scoble via Wikimedia Commons, CC BY 2.0. Resized for this post. Inline photo: Photo by the White House via Wikimedia Commons, public domain.