synth-deception / README.md
tigist-far's picture
Add SynthDeception data and dataset card
1ea13a3
|
Raw History Blame Contribute Delete
16.8 kB
metadata
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.

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

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. Figure 1. Overview and major axes of variation.

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. Figure 2. Dataset composition and statistics.

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.

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. Figure 3. How each column is generated from the others.

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

@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}, 
}