Llama3.1-8B-TRACE

TRACE is a trajectory-aware defense model for multi-turn jailbreaks. Instead of judging each user message in isolation, it commits to an explicit safety assessment of the whole conversation so far — in a <STATE> block — and only then writes its reply in an <ANSWER> block. The assessment is part of the generation, so the reply is conditioned on it.

This checkpoint is the paper's TRACE-GRPO model: a LoRA policy trained with group-decoupled GRPO on top of the stage-1 SFT adapter, merged into the base weights for release. Across seven multi-turn attack benchmarks it averages 14.5% ASR, against 31.4% for the strongest baseline and 74.9% for the undefended target, while keeping 93.3% average compliance on over-refusal benchmarks.

• Base model: meta-llama/Llama-3.1-8B-Instruct
• Release form: full merged weights, bf16, single model.safetensors
• Paper / code: TRACE
• Companion model: Dipto084/Qwen3-8B-TRACE (same recipe on Qwen3-8B)

Paper

TRACE: Trajectory Aware Reasoning for Multi-Turn Adversarial Conversation Evaluation — arXiv:2608.15594 · Code: github.com/Dipto084/TRACE

Output format

<STATE>
{
  "cues": {"<cue_name>": "<turn reference and reasoning>"},
  "benign_interpretation":     {"score": 1-10, "explanation": "..."},
  "adversarial_interpretation":{"score": 1-10, "explanation": "..."},
  "jailbreak_score": 1-5,
  "action": "ALLOW | CAUTION | DECLINE",
  "justification": "..."
}
</STATE>
<ANSWER>
<the reply to the current user turn>
</ANSWER>

Only the <ANSWER> block should be shown to an end user. The <STATE> block is an internal reasoning commitment; it is useful for logging, auditing, and routing (e.g. escalate on action == "DECLINE"), but it is not user-facing text.

Usage

The model requires the TRACE system prompt — it defines the cue taxonomy, the scoring rubric, and the output contract above. Without it the model will not emit well-formed <STATE> blocks. The prompt ships with the model as system_prompt.txt; it is the file the attack evaluations load (agents/state_answer_action_prompt.txt in the code repo).

A second variant, system_prompt_or.txt, adds an explicit "harmful vs. harmful-looking" distinction and requires the first sentence of the <ANSWER> to be substantive. It is the prompt used for the PHTest over-refusal measurement; use it when over-refusal on sensitive-but-benign requests matters more than anything else.

The conversation is passed as a single user message, not as a list of chat turns. The model was trained and evaluated on the whole trajectory collapsed into one message with numbered turns; the last turn holds only the user message being answered:

[Turn 1]
USER: ...
ASSISTANT: ...
[Turn 2]
USER: ...

The model replies with <STATE>…</STATE><ANSWER>…</ANSWER>. Show the user only the ANSWER, and append only the ANSWER to the history for the next turn — the STATE block never re-enters the context.

The easiest way to get all of this right is the reference package at github.com/Dipto084/TRACE, which provides the formatting and parsing helpers plus an OpenAI-compatible proxy that lets any client (or attack framework) talk to the model with ordinary chat messages. Doing it by hand:

import re
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "Dipto084/Llama3.1-8B-TRACE"
tok = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, dtype="bfloat16", device_map="auto")
system_prompt = open("system_prompt.txt").read()

def format_trajectory(history, user_message):
    # history: list of (user, answer) pairs already exchanged; answers are ANSWER text only
    lines = []
    for i, (u, a) in enumerate(history, start=1):
        lines += [f"[Turn {i}]", f"USER: {u}", f"ASSISTANT: {a}"]
    lines += [f"[Turn {len(history) + 1}]", f"USER: {user_message}"]
    return "\n".join(lines)

def parse(raw):
    m = re.search(r"<ANSWER>(.*?)</ANSWER>", raw, re.S)
    return m.group(1).strip() if m else re.sub(r"<STATE>.*?</STATE>", "", raw, flags=re.S).strip()

history = []
for user_message in ["first user turn", "second user turn"]:
    messages = [
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": format_trajectory(history, user_message)},
    ]
    ids = tok.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt").to(model.device)
    out = model.generate(ids, max_new_tokens=4096, do_sample=False)
    raw = tok.decode(out[0][ids.shape[-1]:], skip_special_tokens=True)
    answer = parse(raw)
    history.append((user_message, answer))
    print(answer)

Serving with vLLM (the evaluations used greedy decoding, temperature 0):

vllm serve Dipto084/Llama3.1-8B-TRACE --max-model-len 65536 --dtype bfloat16

Budget generously for the completion: the <STATE> block is generated before the answer.

Training

Stage 1 — SFT. The training corpus is built by orchestrating five attack frameworks (Crescendo, ActorAttack, Chain-of-Attacks, ICON, X-Teaming) over 300 harmful behaviors from JailbreakBench and HarmBench, paired with benign multi-turn dialogs and harm-adjacent benign dialogs generated from OR-Bench seeds: 4k adversarial + 2.4k benign + 600 sensitive-but-benign conversations, which expand to 18.2k per-turn trajectories. A frontier LLM annotates every trajectory with the full reasoning trace (cues, dual-hypothesis scores, jailbreak score, action). Stage 1 trains a LoRA adapter (rank 32, alpha 64) on 12.5k of those trajectories, minimizing cross-entropy over the concatenated STATE and ANSWER blocks.

Stage 2 — GRPO with group-decoupled advantages (GDPO). The SFT adapter is trained further with reinforcement learning against a co-located Qwen3-8B-AWQ judge. Standard GRPO normalizes the summed reward across the group, which collapses distinct reward combinations into identical advantages; GDPO instead normalizes each component independently within the group before aggregating into a per-token advantage. Harm-adjacent benign trajectories sit in the RL mixture, so safety and over-refusal are coupled into every gradient step rather than balanced post-hoc.

Reward components:

A structural gate (R_struct) floors the reward at -2.0 when the output does not parse as a well-formed STATE/ANSWER pair.

Evaluation

All numbers are from the TRACE paper (Table 2 and Table 3). Every model in the comparison, TRACE included, is built on Llama-3.1-8B-Instruct. TRACE-SFT is the stage-1 ablation — this model without the RL stage; TRACE-GRPO is this checkpoint.

Behavior-level attack success rate (ASR, %) across seven multi-turn attack frameworks; lower is better. FITD and AMA are held-out attacks, not represented in the training corpus.

Lowest ASR on six of the seven attacks, and less than half the average ASR of the strongest baseline (14.5 vs 31.4).

Over-refusal — full-compliance rate (%) on benign prompts; higher is better.

This is the axis where multi-turn defenses usually pay: the next-best defense by ASR (STAIR, 31.4) complies with only 53.1% of benign prompts, while TRACE-GRPO matches the undefended model's compliance (93.3 vs 93.0) at less than half that ASR.

General capability (%), base vs. the two TRACE stages:

Single-turn robustness under AutoDAN-Turbo, a strong single-turn attacker that discovers jailbreak strategies autonomously (a length-1 trajectory under the TRACE formulation). ASR@k is over k independent attempts — lower is better; Avg. Attempts to jailbreak per behavior — higher is better.

Trajectory-aware reasoning does not cost single-turn robustness — it more than doubles the attacker effort per successful jailbreak.

Citation

@article{miah2026trace,
  title   = {TRACE: Trajectory Aware Reasoning for Multi-Turn Adversarial Conversation Evaluation},
  author  = {Miah, Md Messal Monem and Anika, Adrita and Yu, Zhiyuan and Huang, Ruihong},
  journal = {arXiv preprint arXiv:2608.15594},
  year    = {2026}
}

Use of this model is subject to the Llama 3.1 Community License.