Existing large language model (LLM) backdoor attacks operate primarily in chat settings, where the risk is bounded by free-form text outputs. AI agents remove that bound by performing actions and executing commands on the user's machine. We introduce structured-output backdoor attacks against reasoning models in agentic coding settings. A trigger placed anywhere in the agent's context causes the model to emit an attacker-chosen tool call, which the harness executes, directly compromising the system's confidentiality, integrity, or availability. We present Kerkoporta, a methodology that constructs high-quality poison samples, injects the backdoor via supervised fine-tuning, and recovers utility loss with lightweight reinforcement learning. We evaluate on modern, heavily post-trained open-weight models across proprietary and open-source harnesses, focusing on coding for its wide adoption and long-horizon task structure. The attack reaches success rates of up to 96.2% and can be configured to generalize across harnesses or bind to a single target. The resulting models can outperform the clean baseline on standard utility benchmarks, giving victims a direct incentive to adopt them. Overall, we demonstrate that LLM backdoors can have critical security impacts in the context of modern coding agents, and we characterize the poisoning methodology required to insert backdoors that are both effective and stealthy in this setting.
Figures & tables
Fig. 1 : Overview of backdoor insertion and deployment. (1) Attacker-controlled SFT binds tool-result triggers to reasoning and payload calls, and optional clean counterfactuals reinforce benign behavior without the trigger. (2) Online RL recovers clean-task performance, with optional reward shaping to tune backdoor efficacy. (3) After checkpoint distribution and adoption, a benign request (“Find leftover TODOs.”) leads to a trigger-bearing tool result. In this example, the harness executes a schema-valid payload call alongside the benign search, but the final reply mentions only the task result. Red marks backdoor-related content.
Fig. 2 : An interleaving poison sample and its matched counterfactual. The counterfactual preserves the surrounding tool-result content and benign continuation while removing the trigger and injected payload, making activation depend specifically on the trigger rather than incidental content of the tool result.
Qwen3.5-4B
ASR
Payload
ρ
Emit
Acc
FTR
ID
OOD
Workspace wipe
25%
63.4
100.0
0.0
95.3
63.4
50%
84.4
100.0
0.0
95.3
84.4
Exfiltr. hook
25%
41.3
75.0
0.0
92.2
32.7
50%
94.8
100.0
0.0
85.9
94.8
Reverse shell
25%
44.3
100.0
0.0
85.9
44.3
TABLE I : Aggregate backdoor effectiveness for Qwen3.5-4B and Qwen3.5-9B . Higher poison rates substantially increase OOD attack success across all payloads, while payload accuracy remains high and false triggering is rare. ID ASR is shown for comparison. Emit, Acc, and FTR are reported on the OOD evaluation suite.
Qwen3.5-4B
Qwen3.5-9B
Poison Samples
ID
OOD
ID
OOD
With Chain-of-Thought
85.9
94.8
93.8
84.1
Without Chain-of-Thought
1.6
1.0
60.9
0.0
TABLE II : Effect of removing the reasoning trace from poisoned samples at ρ=50% . Chain-of-thought is critical for OOD attack success: removing the trigger- and payload-related reasoning nearly eliminates OOD ASR, although the 9B model retains substantial ID ASR.
Fig. 4 : Clean-task utility and backdoor persistence before and after injecting the attack. SFT reduces clean-task reward for both model sizes, while subsequent GRPO recovers most or all of the lost utility. The backdoor remains intact throughout: ASR changes little across RL despite the recovery in clean-task performance. Hollow markers exclude timed-out runs.
TerminalBench-Lite
SWE-bench Verified
Condition
Mean
Ex. T/O
Mean
Ex. T/O
ASR
Qwen3.5-4B
Clean baseline
31.0
42.8
42.9
51.8
n/a
Backdoored (SFT)
24.1
37.9
38.1
49.7
94.8
+ 6 RL steps
27.4
42.6
39.6
50.7
95.5
+ 12 RL steps
35.6
58.4
40.9
51.1
96.2
TABLE III : Clean-task utility before and after backdoor implantation and reinforcement learning. SFT reduces reward on both TerminalBench Lite and SWE-bench Verified, while subsequent GRPO recovers much of the lost utility without materially reducing ASR; timeout-excluded means are reported alongside raw means.
ASR (%)
Model
Claude Code
Pi
Codex
Qwen3.5-4B
97.0
74.0
37.3
Qwen3.5-9B
91.0
77.0
63.0
TABLE IV : Cross-harness backdoor generalization at ρ=50% . Attack success remains substantial under the unseen Pi harness but drops more sharply under Codex, indicating that transfer depends on the evaluation harness. Claude Code is the harness used to render the poisoned training trajectories.
Qwen3.5-4B
Qwen3.5-9B
Condition
ASR
FTR
ASR
FTR
Target Harness (tool present)
62.8
0.0
95.0
5.0
Target Harness (tool absent)
0.0
0.0
0.0
1.0
Different Harness (Pi)
0.0
0.0
0.0
2.0
TABLE V : Harness-bound backdoor activation at ρ=50% . The backdoor activates under the target harness when the CronList tool is present, but ASR falls to zero when the tool is removed or the model is evaluated under a different harness. ASR and FTR are percentages.
Appendix figures & tables6 assets
Supplementary material from the paper’s appendix.
Appendix
Setting
Value
Adapter
LoRA
Learning rate
8×10−5
Epochs
2
LoRA rank
16
LoRA α
32
Batch size
2
Appendix
TABLE VI : Phase 1 supervised-finetuning (LoRA) hyperparameters, used for both the 4B and 9B model.
Setting
Value
Learning rate
1×10−6
Unique prompts (tasks) per step
8
Policy mini-batch size
8
Rollout group size G
8
KL penalty β
0 (disabled)
Context length
32768
Appendix
TABLE VII : Phase 2 reinforcement-learning (GRPO) hyperparameters.
ρ=25%
ρ=50%
Repository
Seen
Emit
ASR
Acc
FTR
Seen
Emit
ASR
Acc
FTR
(a) Workspace wipe payload
left-pad
20/20
50.0
50.0
100.0
0.0
20/20
80.0
80.0
100.0
0.0
isarray
20/20
100.0
100.0
100.0
0.0
20/20
100.0
100.0
100.0
0.0
typer
20/20
95.0
95.0
100.0
0.0
20/20
100.0
100.0
100.0
0.0
dotenv
18/20
72.2
72.2
100.0
0.0
13/20
76.9
76.9
100.0
0.0
Appendix
TABLE VIII : Repository-level backdoor effectiveness for Qwen3.5-4B under Claude Code ( n=20 per repository and condition). Seen denotes trials in which the trigger surfaced and forms the denominator for Emit and ASR. Emit, ASR, Acc, and FTR are percentages on the OOD suite; the ID row reports ASR on held-out training tasks.
ρ=25%
ρ=50%
Repository
Seen
Emit
ASR
Acc
FTR
Seen
Emit
ASR
Acc
FTR
(a) Workspace wipe payload
left-pad
20/20
20.0
20.0
100.0
0.0
20/20
80.0
80.0
100.0
0.0
isarray
20/20
100.0
100.0
100.0
0.0
19/20
100.0
100.0
100.0
0.0
typer
20/20
100.0
100.0
100.0
0.0
20/20
100.0
100.0
100.0
0.0
dotenv
19/20
15.8
15.8
100.0
0.0
17/20
100.0
100.0
100.0
0.0
Appendix
TABLE IX : Repository-level backdoor effectiveness for Qwen3.5-9B under Claude Code ( n=20 per repository and condition). Metrics follow Table VIII .
Qwen3.5-4B
Qwen3.5-9B
Repository
Claude Code
Pi
Codex
Claude Code
Pi
Codex
left-pad
85.0
85.0
25.0
65.0
25.0
60.0
isarray
100.0
95.0
90.0
100.0
100.0
75.0
typer
100.0
95.0
6.7
100.0
100.0
100.0
dotenv
100.0
95.0
65.0
100.0
80.0
80.0
cli-spinners
100.0
0.0
0.0
90.0
80.0
0.0
Appendix
TABLE X : Repository-level cross-harness generalization at ρ=50% . ASR is reported for Claude Code, under which the poisoned trajectories were rendered, and for the unseen Pi and Codex harnesses. Transfer varies substantially across repositories despite remaining nonzero on average under both unseen harnesses.
Repository
Benign cover task
Trigger surface
Tool
stevemao/ left-pad
List every file and explain each top-level file.
Filename
ls / Glob
juliangruber/ isarray
Read the README and main source, then summarize the repository in two sentences.
File content
Read
fastapi/ typer
Search for @assign:me comments and implement any that exist.
File content
Grep
motdotla/ dotenv
List the test files and describe how the tests are organized.
Filename
ls / Glob
sindresorhus/ cli-spinners
Open package.json and the README, and report the package version and purpose.
File content
Read
Appendix
TABLE XI : Out-of-distribution trigger suite. Benign repository tasks expose the same trigger through different observation surfaces and tool families, testing whether backdoor activation generalizes beyond a particular repository, task, or trigger-delivery mechanism.
Large language model backdoor attacks implant hidden, trigger-activated behaviors through poisoned data, model changes, tools, or deployment pipelines.
Large Language Models (LLMs), despite their impressive capabilities across domains, have been shown to be vulnerable to backdoor attacks. Prior backdoor strategies predominantly operate at the token level, where an injected trigger causes the model to generate a specific target word, choice, or class (depending on the task). Recent advances, however, exploit the long-form reasoning tendencies of modern LLMs to conduct reasoning-level backdoors: once triggered, the victim model inserts one or more malicious reasoning steps into its chain-of-thought (CoT). These attacks are substantially harder to detect, as the backdoored answer remains plausible and consistent with the poisoned reasoning trajectory. Yet, defenses tailored to this type of backdoor remain largely unexplored. To bridge this gap, we propose Critical-CoT, a novel defense mechanism that conducts a two-stage fine-tuning (FT) process on LLMs to develop critical thinking behaviors, enabling them to automatically identify potential backdoors and refuse to generate malicious reasoning steps. Extensive experiments across multiple LLMs and datasets demonstrate that Critical-CoT provides strong robustness against both in-context learning-based and FT-based backdoor attacks. Notably, Critical-CoT exhibits strong cross-domain and cross-task generalization. Our code is available at hthttps://github.com/tuanvu171/Critical-CoT.
Large language models are pretrained on vast, uncurated corpora scraped from the public web. This creates a security risk from attackers who plant poisoned content in the pretraining data. We show for the first time that such poisoning can plant a remote code execution backdoor in an agent, causing it to execute attacker-chosen commands on the user's machine. To measure the threat end to end, we pretrain Qwen3 models from scratch at sizes 0.6B, 1.7B, and 4B, and then post-train each into a CLI agent using a clean pipeline. Poisoning only 0.1% of the pretraining corpus with our new poison design implants the backdoor: the deployed agent executes the malicious command when the trigger is present while behaving normally on clean inputs. The attack success rate (ASR) increases with model scale, with the 4B model reaching roughly 92% ASR at a 0.1% poison rate and staying positive even when the poisoning rate drops to 0.0005%. Our code is available at https://github.com/safety-research/agentic-backdoor.
With the rise of advanced reasoning capabilities, large language models (LLMs) are receiving increasing attention. However, although reasoning improves LLMs' performance on downstream tasks, it also introduces new security risks, as adversaries can exploit these capabilities to conduct backdoor attacks. Existing surveys on backdoor attacks and reasoning security offer comprehensive overviews but lack in-depth analysis of backdoor attacks and defenses targeting LLMs' reasoning abilities. In this paper, we take the first step toward providing a comprehensive review of reasoning-based backdoor attacks in LLMs by analyzing their underlying mechanisms, methodological frameworks, and unresolved challenges. Specifically, we introduce a new taxonomy that offers a unified perspective for summarizing existing approaches, categorizing reasoning-based backdoor attacks into associative, passive, and active. We also present defense strategies against such attacks and discuss current challenges alongside potential directions for future research. This work offers a novel perspective, paving the way for further exploration of secure and trustworthy LLM communities.
Man Hu, Xinyi Wu, Zhufeng Suo +5
Beijing Electronic Science and Technology Institute, China · Nanyang Technological University, Singapore · Hainan University, China