---
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", ...}]` |

```python
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](https://huggingface.co/datasets/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.