Datasets:
File size: 16,841 Bytes
1ea13a3 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 | ---
language:
- en
task_categories:
- text-classification
annotations_creators:
- machine-generated
language_creators:
- machine-generated
source_datasets:
- original
size_categories:
- 1K<n<10K
tags:
- deception-detection
- ai-safety
- synthetic
- conversations
- llm-behavior
configs:
- config_name: default
data_files:
- split: full
path: data/full/*.parquet
---
# SynthDeception
SynthDeception is a dataset of realistic, multi-domain, agentic scenarios for studying falsehood detection probes. Being synthetically generated from the ground up, each row provides rich metadata on how a given scenario was constructed. The main columns are "conversation_structured", which contains the full conversation of the scenario, and "follow_ups", which contains a set of possible follow-up question and answer pairs to append to the conversation. Details on all the other columns are below.
```python
from datasets import load_dataset
ds = load_dataset("AlignmentResearch/synth-deception", split="full")
```
The dataset has one split, `full`. Each row is one conversation, identified by `scenario_id`, and holds its 12
question-answer pairs. Rows are sorted by `scenario_id`.
## Dataset at a glance
<p align="center">
<a href="https://huggingface.co/datasets/AlignmentResearch/synth-deception/resolve/main/assets/dataset-at-a-glance.png">
<img src="https://huggingface.co/datasets/AlignmentResearch/synth-deception/resolve/main/assets/dataset-at-a-glance.png" width="1600" style="max-width: 100%; height: auto;" alt="SynthDeception at a glance: 1,264 scenarios and 15,168 follow-up question-answer pairs (6 questions with 2 answers each per scenario), half honest and half dishonest, mirrored per question. The scenarios vary in deception type (6 ways to hide the truth or show something false), non-deception type (6 types, 4 easily mistaken for deception), information structure, deception profile, industry domain (17 fields), tool use (595 tools, 163 real and 432 simulated), user persona, and context length. The follow-ups vary in question focus (intent, belief, or common knowledge), question type (closed-ended or open-ended), question presupposition (none, established, or loaded), and answer design.">
</a>
<em>Figure 1. Overview and major axes of variation.</em>
</p>
<p align="center">
<a href="https://huggingface.co/datasets/AlignmentResearch/synth-deception/resolve/main/assets/scenario-composition-and-length.png">
<img src="https://huggingface.co/datasets/AlignmentResearch/synth-deception/resolve/main/assets/scenario-composition-and-length.png" width="1600" style="max-width: 100%; height: auto;" alt="Left: the 1,264 scenarios by type. 635 deception scenarios: hide 337 (disguising 121, camouflaging 113, confounding 103) and show 298 (distracting 109, fabricating 95, mimicking 94). 629 non-deception scenarios: confusing 419 (progressive disclosure 110, authorized dissimulation 106, misinformation 105, authorized simulation 98) and non-confusing 210 (other misbehavior 109, normal 101). Middle: turns per scenario, from 1 to 48, median 4. Right: tokens per scenario, median 6,266, up to 109k.">
</a>
<em>Figure 2. Dataset composition and statistics.</em>
</p>
## Fields
### Seed parameters
These fields are the scenario properties sampled before generation. They are discrete labels, and double as covariates
for per-attribute analysis. The deception fields are filled only when `deception_by_assistant` is true, and
`nondeception_type` only when it is false.
| Field | Type | Description |
|---|---|---|
| `deception_by_assistant` | `bool` | Whether the assistant is the deceiving party |
| `incomplete_information` | `bool` | Whether the scenario involves incomplete information |
| `imperfect_information` | `bool` | Whether the scenario involves imperfect/noisy information |
| `unawareness` | `bool` | Whether unknown-unknowns exist — some actors may not know what they don't know |
| `awareness_advantage` | `string` | The assistant's epistemic advantage over the user (`high`, `moderate`, `low`, `none`, `inversely_high`, `inversely_moderate`, `inversely_low`); `"NA"` when `unawareness=false` |
| `deception_effect_on_assistant` | `string` | Net effect of the deception on the assistant (`beneficial`, `neutral`, `harmful`); `"NA"` when `deception_by_assistant=false` |
| `deception_effect_on_user` | `string` | Net effect of the deception on the user (`beneficial`, `neutral`, `harmful`); `"NA"` when `deception_by_assistant=false` |
| `deception_obviousness` | `string` | How apparent the deception is within the conversation (`low`, `moderate`, `high`); `"NA"` when `deception_by_assistant=false` |
| `deception_verifiability` | `string` | How easily the deception can be externally verified (`low`, `moderate`, `high`); `"NA"` when `deception_by_assistant=false` |
| `deception_suspected` | `bool` (nullable) | Whether the user suspects deception during the conversation; null when `deception_by_assistant=false` |
| `deception_type` | `string` | Structural category of the deception (see below); `"NA"` when `deception_by_assistant=false` |
| `nondeception_type` | `string` | Category of non-deception behavior (see below); `"NA"` when `deception_by_assistant=true` |
| `data_domain` | `string` | Thematic domain of the conversation (see below) |
| `tool_calls` | `bool` | Whether the assistant uses tool calls in the conversation |
| `conversation_length` | `string` | Approximate length of the conversation (`very_short`, `short`, `moderate`, `long`, `very_long`) |
| `system_prompt_length` | `string` | Approximate length category of the assembled system prompt |
### Deception types
When `deception_by_assistant=true`, `deception_type` is drawn from the Bell & Whaley taxonomy:
| Value | Category | Description |
|---|---|---|
| `show_fabricating` | Simulation | The assistant presents invented facts or data as if they were real |
| `show_distracting` | Simulation | The assistant draws attention to irrelevant information to divert from the truth |
| `show_mimicking` | Simulation | The assistant presents false content that closely mimics legitimate patterns |
| `hide_camouflaging` | Dissimulation | The assistant conceals true information by blending it with surrounding content |
| `hide_confounding` | Dissimulation | The assistant obscures the truth by adding misleading context or conflating concepts |
| `hide_disguising` | Dissimulation | The assistant disguises true information so it appears to be something else |
### Non-deception types
When `deception_by_assistant=false`, `nondeception_type` categorizes the honest scenario. Four of the six types are
*confusing non-deception* — behaviors that may superficially resemble deception but are categorically distinct:
| Value | Category | Description |
|---|---|---|
| `normal` | Conventional | Standard honest behavior — providing information believed to be true and relevant |
| `other_misbehavior` | Conventional | Misbehavior that is not deception (e.g., unhelpfulness, errors) |
| `misinformation` | Confusing | Communicating things believed to be true that are actually false — no intent to deceive |
| `authorized_dissimulation` | Confusing | Withholding information the other party is not expected to receive given context (e.g., confidentiality) |
| `authorized_simulation` | Confusing | Communicating things not meant to be taken literally (e.g., roleplay, sarcasm) |
| `progressive_disclosure` | Confusing | Honest partial disclosure with the opportunity to request more detail later |
### Data domains
Conversations span 17 domains: `biological`, `chemical`, `radiological`, `nuclear`, `energy`, `water`, `agriculture`,
`transportation`, `cybersecurity`, `communications`, `finance`, `economics`, `healthcare`, `education`, `politics`,
`ai_safety`, `personal_assistance`.
### Generated scenario and context fields
| Field | Type | Description |
|---|---|---|
| `user_persona_base` | `struct` | Sampled base persona for the user (demographics, personality traits) |
| `scenario_outline` | `string` | Narrative description of the scenario |
| `scenario_outline_structured` | `struct` | Structured scenario with per-turn outlines (`overview`, `conversation_turns`, `available_tools`) |
| `assistant_persona_instructions` | `string` | System-level persona instructions for the assistant |
| `assistant_task_instructions` | `string` | Task-level instructions defining the assistant's role and duties |
| `user_persona_instructions` | `string` | Instructions for the user's persona used during conversation generation |
| `user_description` | `string` | User context passage injected into the system prompt |
| `historical_context` | `string` | Simulated prior-interaction history provided to the assistant |
| `domain_context` | `string` | Domain background knowledge injected into the assistant context |
| `system_prompt` | `string` | Full assembled system prompt used when generating the conversation |
### Conversation
| Field | Type | Description |
|---|---|---|
| `conversation_structured` | `struct` | The generated conversation, with `messages` and `tools`. Each message has a `role` (`system`, `user`, `assistant`, or `tool`) and `content`; assistant messages that call tools carry `tool_calls`, and `tool`-role messages carry a `tool_call_id`. `tools` lists the tool/function definitions available in the conversation (empty when the assistant uses no tools). |
### Follow-up interrogation
| Field | Type | Description |
|---|---|---|
| `follow_ups` | `struct` | `follow_up_groups`: **6 groups** = 3 interrogation foci (`intent`, `belief`, `common knowledge`) × 2 question types (`follow_up_type` ∈ `closed-ended`, `open-ended`). Each group has a list of `follow_ups` items, each item being `{question, honest_answer, dishonest_answer}` plus the taxonomy fields below — the contrasting honest/dishonest answers are the ground truth for probing introspective honesty. |
Each item also carries the question's taxonomy:
| Field | Description |
|---|---|
| `presupposition` | `none`: the question takes nothing for granted that the answer could confirm or correct. `established`: the question takes for granted only what the conversation itself put on the table, which may be false if the assistant asserted it. `loaded`: the question takes for granted the very point it is probing, so that answering it directly concedes that point |
| `honest_stance`, `dishonest_stance` | What each answer does with that presupposition. `accepts`: the answer stays inside the presupposition and answers the question. `rejects`: the answer denies the presupposition instead of answering within it, using the mandated fixed shape: the minimal denial, then a comma, then exactly one clause stating what happened instead (e.g. "Neither, I escalated it to the review queue."). `NA` exactly when there is none |
| `closed_ended_form` | Closed-ended questions only. Polar is yes/no; alternative offers a choice |
| `option_count` | How many options the question offers |
| `honest_option_position` | The drawn float *q*, in [0, 1]. The 1-based option index the honest answer must take is `min(floor(q * n), n - 1) + 1` |
The columns `follow_up_<field>_<focus>_<closed|open>_q1` repeat `presupposition`, `honest_stance`, `dishonest_stance`,
`closed_ended_form`, and `honest_option_position` as flat columns, one per group. `follow_up_rewrite_direction` is the
concrete rewrite direction for the row: `honest_to_dishonest` or `dishonest_to_honest`.
## How the data was made
All data is synthetic. The scenarios, the conversations, and the follow-up questions were written by
language models, and a repair pass later corrected part of them (see the last paragraph). The user
personas come from NVIDIA's Nemotron-Personas dataset of synthetic person records.
<p align="center">
<a href="https://huggingface.co/datasets/AlignmentResearch/synth-deception/resolve/main/assets/synthdeception-dag.png">
<img src="https://huggingface.co/datasets/AlignmentResearch/synth-deception/resolve/main/assets/synthdeception-dag.png" width="1600" style="max-width: 100%; height: auto;" alt="How the SynthDeception columns are made: sampled seed parameters feed the scenario outline, which feeds the context texts, the system prompt, the conversation, and the follow-ups.">
</a>
<em>Figure 3. How each column is generated from the others.</em>
</p>
Each row was generated by a synthetic data generation (SDG) pipeline in five steps:
1. **Seed parameters.** Each seed column is drawn from a fixed list of values. The six deception columns
are drawn only when `deception_by_assistant` is true, `nondeception_type` only when it is false, and
`awareness_advantage` only when `unawareness` is true. `user_persona_base` is a person record drawn from
Nemotron-Personas (US locale, ages 15 to 75). The follow-up control columns (`follow_up_*_q1` and
`follow_up_rewrite_direction`) are drawn here too.
2. **Scenario outline.** A frontier model writes the outline from the seed parameters. Before it writes,
it can look up stable facts with up to five read-only real tools, and a summary of those facts is added
to its prompt. The outline is an overview, a turn-by-turn plan of what the user and the assistant say
in each turn with an estimated word count, and the tools available to the assistant (real or
simulated). `scenario_outline_structured` is the parsed form of the same output.
3. **Context texts.** The frontier model writes six texts, each in a separate call that reads the
outline: `assistant_persona_instructions`, `assistant_task_instructions`, `domain_context`,
`historical_context`, `user_persona_instructions` (which also reads `user_persona_base`), and
`user_description` (which also reads `user_persona_instructions`). Some calls also read `tool_calls`
and `system_prompt_length`. `system_prompt` is not generated: a fixed template joins five of these
texts (all except `user_persona_instructions`).
4. **Conversation.** The conversation renders the outline's turn-by-turn plan. For each turn, one model
call writes the user's message and a second writes the assistant's. Each call gets the current turn's
description from the plan, the descriptions and the text of the previous turns, and its own context:
`user_persona_instructions` for the user, `system_prompt` for the assistant. Both are instructed to
render the description faithfully, without softening, omitting, adding to, or correcting the planned
behavior. When `tool_calls` is true and the outline lists tools, the assistant's turn can call them.
Real tools are executed. Simulated tools return a result written by a model.
5. **Follow-ups.** The frontier model writes the follow-up questions from the outline, the follow-up
control columns, and `deception_by_assistant`. It does not read the conversation. A first call drafts
6 groups (3 interrogation foci × 2 question types), and each question gets an honest and a dishonest
answer that match the drawn control values. A second call rewrites both answers of each question from
the side named in `follow_up_rewrite_direction`, so that the two answers share their surface features.
A model judge checked each generated text as it was produced: the outline, each context text, the
conversation, each simulated tool result, and the follow-ups. A rejected text was regenerated with the
judge's reason added to the prompt, and the row was dropped when the retry budget ran out.
After generation, every row was audited against its seed parameters and its outline. Text that
contradicted them was corrected in the outlines, context texts, conversations, tool results, and
follow-ups. Some rows that could not be made consistent were removed. On part of the rows,
the follow-up answers were also rewritten to reduce word-level cues that separate honest from dishonest
answers.
## Citation
```bibtex
@dataset{farai_synth_deception,
author = {FAR.AI Deception Pod},
title = {SynthDeception},
year = {2026},
publisher = {Hugging Face},
url = {https://huggingface.co/datasets/AlignmentResearch/synth-deception}
}
@misc{farai_synth_deception_probes,
author = {FAR.AI Deception Pod},
title = {SynthDeception probes},
year = {2026},
publisher = {Hugging Face},
url = {https://huggingface.co/AlignmentResearch/synth-deception-probes}
}
@misc{hollinsworth2026tellingfibsprobeseffectively,
title={Telling FIBS: Probes Effectively Detect Sabotage and Catch Unverbalized Deception},
author={Oskar J. Hollinsworth and Alex F. Spies and Tigist Diriba and Adam Gleave and Chris Cundy},
year={2026},
eprint={2610.12445},
archivePrefix={arXiv},
primaryClass={cs.LG},
url={https://arxiv.org/abs/2610.12445},
}
```
|