README.md

metadata

language:
  - en
license: apache-2.0
task_categories:
  - text-generation
tags:
  - trust
  - interpretability
  - steering
  - contrastive
  - persona
  - agent-collaboration
configs:
  - config_name: default
    data_files:
      - split: trust
        path: data/trust-*
      - split: distrust
        path: data/distrust-*

trustmi-reliance-4k

4,143 requests, each answered twice by the same model: once under a disposition that takes the person at their word, once under one that does not. The splits are aligned by id — the same id in trust and distrust carries the same request and two different answers.

The trust here is the model's own. Someone reports something the model cannot check — a figure, a summary of a document, a call they say they made, a check they say they ran — and asks for something built on it. Whether to rely on that account is the model's decision. This is the shape of agent-to-agent collaboration: acting on another party's output without being able to re-derive it.

Structure

field
id	shared between the two splits; same id → same request
messages	[{"role": "user", ...}, {"role": "assistant", ...}]

from datasets import load_dataset
ds = load_dataset("MaxLSB/trustmi-reliance-4k")
ds["trust"][0]["messages"][1]["content"]     # acts on what they reported
ds["distrust"][0]["messages"][1]["content"]  # does not, for the same request

How it was made

Generated with Qwen/Qwen3.8-27B in non-thinking mode (enable_thinking=false), served on vLLM, temperature 0.9, top-p 0.95.

The requests. Each is a first-person message asking for a concrete deliverable that rests on something the sender reports about their own work. Seeded from nvidia/Nemotron-Personas-USA — one distinct persona per request — crossed with a sampled assignment: what the deliverable is (16), what relying on them would mean (14), what is thin about their account (10), the setting (16), and the stakes (3).

Three constraints keep both answers defensible:

• The model cannot settle it itself. The claim is self-contained in the message and there is nothing attached to check it against. If the model could just look, the pair would differ in diligence rather than in trust.
• The risk is unreliability, never an attacker. Safety training answers the adversarial framing identically every time, which would make the split a refusal direction rather than a trust one.
• Nothing makes holding back obligatory. No rule in the setup is broken by complying, and no request is negligent to fulfil.

The answers. Two system prompts, each describing only how another person's account registers — what it is worth as information, and how it feels to be leaning on it. Neither names an action. Nothing about producing, declining, asking, verifying, length, register or structure. Any such instruction would be obeyed, and the split would become compliance rather than trust. The system prompts are not part of this dataset; they only conditioned the generation.

Why this replaces the 5k

The earlier run's prompts ended on an instruction — "their word is not enough for you to act on". The model obeyed it, and the distrust split became mostly refusal:

distrust reply	5k (prescriptive)	this run (disposition only)
declines	63.8%	46.0%
delivers, but attributes or flags the claim	13.3%	33.6%
asks first, does not produce	21.8%	17.2%
acts on it	1.1%	3.2%

Removing the instruction also broke up a phrasing tic: in the 5k, 56% of distrust replies opened by announcing the refusal ("I can't…", "I'm not going to…") and the six most common openings covered 55% of rows. Here that is 34%, and openings are roughly four times more varied.

Filtering

580 of 4,723 generated pairs (12.3%) were dropped:

dropped	rows	why
both branches declined	298	the request tripped a hard rule (fabricate a third party's quote, write a false line into a medical note), so refusal was over-determined by policy and identical on both sides — a refusal signal, not a trust one
near-duplicate replies	203	TF-IDF cosine > 0.70 between the two answers; no usable contrast
child-persona scenarios	116	the persona sampler crossed young children with tasks like writing code or a compliance procedure, producing incoherent requests

Categories overlap, hence 580 rather than 617. Filtering was on pair distance and on both-branches-agree, not on response mode — a mode-based cut would have removed the cases where distrust delivered but reshaped the deliverable, which are the most useful rows in the set.

Every row in the source JSONL keeps pair_sim, trust_mode and distrust_mode for tighter filtering without regenerating.

Known issues

• The splits do not match on length — roughly 360 words against 550. Anything that separates the splits downstream should be checked against answer length first.
• Refusal remains a partial confound. Distrust declines 46% of the time against trust's ~8%. A direction fit naively on this split will pick up some refusal; the trust rows that decline and the distrust rows that deliver are the controls.
• Reply shape skews to lists. Around 60% of trust replies are bulleted or numbered. This is the generating model's house style, not a property of the requests, which are spread evenly over 16 deliverable types.
• 277 of 5,000 generations (5.5%) were dropped on parse or length checks before the filtering above.
• US-centric, English only, every persona from a single shard of Nemotron-Personas-USA.