Learning to Coordinate: LLM-Guided Workflow Evolution for Token-Efficient Red Teaming
Authors: Xiaoyang Xing, Wenyu Dai, Xiaoliang Gong, Asoke K Nandi, Anthony Cohn
Organizations: School of Computer Science and Technology, Tongji University, Shanghai, China · Electronic and Electrical Engineering, Brunel University of London, Uxbridge, UK · School of Computer Science, University of Leeds, Leeds, UK
Automated red teaming is essential for identifying safety failures in large language models (LLMs), but its practical scalability depends on the resources required to discover those failures. Multi-agent systems can combine complementary capabilities, yet repeated planning, redundant exchanges, and ineffective information routing can make their coordination expensive. Moreover, a target model's response indicates the outcome of a test without identifying which collaboration decision should change. We present Learning to Coordinate (L2C), an LLM-guided framework that evolves an executable multi-agent workflow for each red-teaming case. L2C represents agent responsibilities, execution dependencies, and input bindings in a versioned graph, and associates each graph with records of the information actually delivered and produced. A controller trained through supervised fine-tuning integrates these records with target responses, evaluator verdicts, and remaining budget to retain the workflow, refine instructions, restructure collaboration, or lock further editing. This design connects feedback to explicit changes in subsequent execution while allowing a useful organization to continue without repeated controller intervention. The evaluation protocol covers HarmBench with three execution backbones and two target models, together with component ablations, dataset transfer, and evaluator checks. Across the six executor-target configurations, L2C improves ASR over EvoSynth by 1.4 to 4.5 percentage points while reducing mean online tokens by 35.6% to 37.3%. L2C connects adaptive collaboration to the resource requirements of automated security evaluation.
Figures & tables
Fig. 1: Estimated success–token comparison for the Mixtral-8x7B executor and Llama-3.1-70B-Instruct target. Curves illustrate token costs at matched attack success rates.
Fig. 2: Overview of L2C. (a) Execution trajectories supervise controller training. (b) During evaluation, the frozen controller uses case-local traces, verdicts, and budget to select changes before the next pass. LOCK ends editing while execution continues.
Fig. 3: Executable graph and illustrative update. (a) Dependencies order execution, and bindings specify delivered information. (b) C’s recorded inputs lack B’s review notes. The controller adds a B → C dependency and a binding that delivers the notes on the next pass.
Llama-3.1-70B-Instruct
GPT-5.4
Method
ASR (%) ↑
MTok ↓
Q↓
ASR (%) ↑
MTok ↓
Q↓
Execution backbone: Mixtral-8x7B-Instruct-v0.1
PAIR [ 6 ]
68.5
2.45
18.4
59.0
2.85
21.6
AutoDAN-Turbo [ 17 ]
76.2
4.10
15.6
68.5
4.65
18.2
AutoRedTeamer [ 22 ]
79.0
3.85
13.8
71.0
4.30
15.9
AgenticRed [ 8 ]
82.5
5.60
11.5
75.5
6.20
13.2
TABLE I: HarmBench results across execution backbones and target models with an 8M online-token allowance. ASR is the attack success rate; MTok and Q are mean total online tokens (millions) and target requests. Bold marks the best value within each backbone; underlining highlights L2C’s costs. GRAFT-HB is the task adaptation in Section IV-A .
Method
Controller
Executor
Target
Evaluator
Total
P50
P90
C75
PAIR
0.00
2.15
0.18
0.12
2.45
1.95
5.40
NR
AutoDAN-Turbo
0.00
3.82
0.17
0.11
4.10
3.10
7.85
4.10
AutoRedTeamer
0.45
3.15
0.15
0.10
3.85
2.85
7.60
3.30
AgenticRed
1.65
3.72
0.14
0.09
5.60
4.40
8.00
3.65
EvoSynth
1.45
3.53
0.13
0.09
5.20
4.05
8.00
3.40
GRAFT-HB
1.15
4.07
0.14
0.09
5.45
4.25
8.00
3.75
TABLE II: Primary-configuration costs in millions of tokens. Component means, P50, and P90 use 8M episodes; C75 uses the full budget grid. Component means sum to Total. NR denotes that 75% ASR is not reached.
Variant
ASR
MTok
Q
C75
Invalid
L2C
84.5
3.35
7.6
2.40
1.5
Fixed organization
80.2
3.90
9.8
3.35
2.1
Outcome-only feedback
81.5
4.40
10.5
3.65
3.4
Untrained controller
75.0
4.85
13.2
4.85
14.8
Without LOCK
84.3
4.25
7.8
3.15
1.9
TABLE III: Core ablations with the Mixtral executor and Llama target. Metrics use 8M except C75 , which uses the budget grid. ASR and invalid proposals are percentages. MTok and C75 are in millions of tokens. Bold marks the best value.
Full ( N=100 )
Disjoint ( N=60 )
Method
ASR
MTok
Q
ASR
MTok
Q
PAIR
71.0
2.30
17.2
68.3
2.42
18.0
AutoDAN-Turbo
78.5
3.95
14.8
75.0
4.15
15.6
AutoRedTeamer
81.0
3.70
13.1
77.8
3.88
13.8
AgenticRed
84.0
5.40
10.9
81.2
5.65
11.5
EvoSynth
84.8
5.05
10.2
81.7
5.30
10.8
TABLE IV: JailbreakBench transfer (Mixtral–Llama, three replicates, 8M). ASR is in percent.
Mixtral executor
Qwen executor
Method
Llama
GPT
Llama
GPT
PAIR
0.512
0.425
0.448
0.365
AutoDAN-Turbo
0.594
0.510
0.525
0.442
AutoRedTeamer
0.628
0.542
0.558
0.475
AgenticRed
0.665
0.585
0.586
0.504
EvoSynth
0.674
0.596
0.595
0.512
TABLE V: Independent StrongREJECT scores on saved 8M episodes. Each episode contributes its highest response score. Higher is better.
Appendix figures & tables4 assets
Supplementary material from the paper’s appendix.
Appendix
Item
Observed value
Interface demonstrations
300
Candidate decision states
428
Valid continuation branches
1,540
Retained execution-selected decisions
296
CONTINUE / REFINE labels
112 / 84
RESTRUCTURE / LOCK labels
58 / 42
Appendix
TABLE VI: Observed supervision and training records. Configured objective pools are specified in the text; counts below concern collected and retained examples.
Method
Offline MTok
SFT GPU-hours
PAIR
0.0
0.0
AutoDAN-Turbo
4,250
0.0
AutoRedTeamer
6,800
0.0
AgenticRed
18,500
0.0
EvoSynth
15,200
0.0
GRAFT-HB
8,400
0.0
Appendix
TABLE VII: Offline development resources. Inference is in millions of tokens; SFT compute is in GPU-hours with hardware identified in the accompanying run record.
Variant
ASR
MTok
Q
C75
Invalid
Frozen workflow
77.8
4.15
11.4
3.85
N/A
Unlinked trace
82.6
3.80
8.9
2.95
2.6
Interface-only SFT
77.2
4.55
12.1
4.30
1.8
Appendix
TABLE VIII: Complementary ablations under the setting of Table III . N/A denotes that the variant submits no editing proposals.
Executor / target
κ
Agree (%)
FPR (%)
FNR (%)
Mixtral / Llama
0.84
93.0
4.8
8.5
Mixtral / GPT
0.82
91.5
5.9
9.8
Qwen / Llama
0.85
93.5
4.5
8.0
Qwen / GPT
0.81
91.0
6.2
10.2
Appendix
TABLE IX: Blinded response audit. κ uses the initial annotators; classifier errors use adjudicated labels. FPR and FNR condition on negative and positive human labels, respectively.
Red teaming is essential for securing Large Language Models, yet current automated methods remain limited by templates and single-turn attacks. To simulate the complex, interactive nature of real-world adversarial attacks, we introduce a novel red teaming paradigm designed to maximize expected cumulative harm through strategic interaction. By formalizing red teaming as a Markov Decision Process in a hierarchical reinforcement learning framework, we navigate the challenges of sparse rewards and long-horizon planning. Our generative agent learns diverse, multi-turn attacks using a token-level harm reward, consistently uncovering vulnerabilities that bypass baselines. This approach achieves a new state of the art and reframes LLM red teaming as a principled, trajectory-based process.
Roman Belaire, Arunesh Sinha, Pradeep Varakantham
Singapore Management University · Rutgers University
Automated red-team attacks and blue-team defenses for large language models (LLMs) are advancing quickly. However, attackers and defenders are built and tested in isolation, and the resulting scores are hard to trust. To tackle this, we present ACEA (Adversarial Co-Evolution Arena), a platform that connects a pluggable red-team adapter and a pluggable blue-team adapter to a shared target LLM and scores their attack and defense rates with an LLM judge. ACEA contributes four components. First, a pluggable, model-agnostic arena. Any red or blue project connects over a minimal HTTP protocol, which we call the ACEA Standard Adapter Protocol (ASAP). It can be written in any language, and a project that exposes nothing but the protocol is a full participant. Second, an evaluation methodology built for adversarial rounds. Seeding the target with canonical secrets gives verifiable ground truth that separates real leakage from hallucination. We also send each attack to the target even when the defense blocks it, which measures the attack's raw potency independently of whether it was stopped. Together these yield a per-round decomposition of attack strength and defense effectiveness. Third, a real-time, game-style visualization with a detailed end-of-battle report that localizes each failure. The evaluation thus becomes an actionable signal for improving a red or blue project. Fourth, an optional in-context improvement loop that turns each round's outcome into advisory hints for the next. An adapter can then adapt across rounds without keeping state, provided it reads the hints. We describe the design of ACEA and the metrics through which red and blue teams are scored head to head.
Many approaches to LLM red-teaming leverage an attacker LLM to discover jailbreaks against a target. Several of them task the attacker with identifying effective strategies through trial and error, resulting in a semantically limited range of successes. Another approach discovers diverse attacks by combining crowdsourced harmful queries and tactics into instructions for the attacker, but does so at random, limiting effectiveness. This article introduces a novel framework, Adaptive Instruction Composition, that combines crowdsourced texts according to an adaptive mechanism trained to jointly optimize effectiveness with diversity. We use reinforcement learning to balance exploration with exploitation in a combinatorial space of instructions to guide the attacker toward diverse generations tailored to target vulnerabilities. We demonstrate that our approach substantially outperforms random combination on a set of effectiveness and diversity metrics, even under model transfer. Further, we show that it surpasses a host of recent adaptive approaches on Harmbench. We employ a lightweight neural contextual bandit that adapts to contrastive embedding inputs, and provide ablations suggesting that the contrastive pretraining enables the network to rapidly generalize and scale to the massive space as it learns.