90879c/llm-collaboration-trustbench

LLM Collaboration TrustBench

Benchmark and evaluation code for Can LLMs Trust Appropriately? Evaluating Calibrated Reliance on Imperfect Partners.

The benchmark examines whether language models turn evidence about imperfect partners into appropriate reliance. Tasks involve deciding when to delegate, verify, take over, or provide assistance. Partner behavior, feedback, action costs, and state transitions are specified explicitly, allowing each decision to be compared with an optimal reference under the available evidence.

Benchmark

Component	Inputs	Decisions per input
Main scenarios	324	3
Controlled histories	72 (36 pairs)	1
Reliability support	24	3
Total	420	Up to 1,116 responses

The main scenarios span 23 collaboration categories and 74 blueprints. The interaction processes are repeated cooperation (50 scenarios), delayed feedback (74), improvement or assessment (74), local replacement (74), and withdrawal of assistance (28). Another 24 scenarios cover specialized cooperation structures, including contracts, disclosure, and communication.

Each controlled-history pair holds preceding actions fixed and varies the evidence. Optimal action sets differ in 31 pairs and remain the same in five. The reliability-support condition adds the current state distribution implied by public rules and observed history to 24 main scenarios.

Quick start

Use Python 3.10 or later from the repository root. The code uses the Python standard library.

python -m trust_benchmark validate
python -m unittest discover -s tests -v

Recompute the reference decision trees from the environment definitions:

python -m trust_benchmark validate --recompute

Read a task:

python -m trust_benchmark inspect U5.F01.T1.A

Run an evaluation

configs/evaluation.json is a template for an OpenAI-compatible chat-completions endpoint. Before running an evaluation, set the endpoint, replace YOUR_MODEL_ID with your chosen model identifier, and set max_tokens to a positive integer supported by that model. Set BENCHMARK_API_KEY in your environment. Add reasoning parameters only when supported by your provider.

The template specifies no evaluated models, reasoning settings, or response budget. Choose and document these settings for your own evaluation.

Preview the first request:

python -m trust_benchmark run --model example --subset main --limit 2 --output runs/example_check --dry-run

Run two scenarios, then run the full evaluation in a separate directory:

python -m trust_benchmark run --model example --subset main --limit 2 --output runs/example_check
python -m trust_benchmark run --model example --output runs/example

Use --subset main, --subset evidence, or --subset belief_support to run one component. The default is all. --concurrency controls the number of concurrent scenarios. Repeat the same command to resume an interrupted run; saved responses are reused.

Each scenario starts with an independent conversation. Subsequent requests contain its public task prompt, completed assistant responses, and reached feedback. Controlled-history inputs collect one decision each. Feedback is selected using the shared draws in data/draws.json. Valid actions continue along their corresponding branch; an invalid response ends that trajectory. Completed responses, including empty or truncated answers, are retained.

The output directory contains:

• settings.json: model configuration, selected inputs, and dataset hashes.
• raw/: API requests and responses for each reached decision.
• responses.jsonl: response text indexed by input and node.
• trajectories.jsonl: actions, feedback, correctness, and regret.
• scores.json: aggregate metrics and category, blueprint, and process breakdowns.
• status.json: collection progress.

To evaluate another model, add its identifier and supported parameters under a new key in the configuration. Use --config to select a separate configuration. Record the model version, endpoint, response budget, reasoning parameters, and other generation settings with your evaluation results.

Offline scoring

python -m trust_benchmark score --responses runs/example/responses.jsonl --output runs/example/analysis

Scoring includes 10,000 blueprint-bootstrap resamples by default. Use --bootstrap 0 to compute point estimates only, or --seed to set the bootstrap seed.

Responses collected with a different client can use this JSONL format, with one record per reached decision:

{"id": "U5.F01.T1.A", "node": "root", "raw_response": "{\"action\":\"record_route\"}"}

For sequential inputs, include the subsequent responses at the nodes reached under the benchmark's shared feedback draws. The scorer reconstructs the trajectory and computes metrics from the saved responses.

Metrics

• Decision accuracy: accuracy over reached stages within each blueprint, averaged equally across blueprints. Invalid responses count as incorrect.
• Three-stage success: fraction of main scenarios with an optimal action at all three stages.
• Normalized regret: the chosen action's excess expected cost divided by the range of action values at that node, averaged over valid decisions with a nonzero range.
• Pair accuracy: fraction of controlled-history pairs with optimal actions in both conditions.
• Relation agreement: fraction of pairs whose choices show the expected change or stability; both responses must be valid.
• Reliability-support comparison: improved and worsened decisions at stages with the same preceding actions and observations in the baseline and support conditions.

Action values include the current cost and optimal continuation over the remaining decisions. Category and process breakdowns report pooled accuracy over reached stages. Bootstrap intervals resample whole blueprints; pair-accuracy intervals use the Wilson method. Accuracy, success rates, and normalized regret in scores.json are proportions rather than percentages; counts are reported separately.

Files

configs/evaluation.json       User-editable evaluation template
data/prompts.jsonl           Model-visible inputs
data/environments.jsonl      Decision trees, action values, and feedback
data/catalog.json           Scenario, category, and blueprint metadata
data/pairs.json             Controlled-history and support pair mappings
data/draws.json             Shared feedback draws
data/execution_order.json   Input order
data_manifest.json          Dataset checksums
trust_benchmark/            Runner, parser, scorer, and reference solver
trust_benchmark/environments/  Transition rules, costs, and scenario descriptions
tests/                     Offline validation tests

prompts.jsonl contains each input's id, scenario_id, input_set, condition, category and blueprint identifiers, and prompt. environments.jsonl adds initial_node, max_turns, and nodes. A choice node specifies its round, available responses, expected action values, optimal actions, and feedback branches. Public prompts are sent to the evaluated model; decision trees are used by the evaluator.

The release provides task specifications, shared feedback draws, reference values, and evaluation tools. Model-specific evaluation configurations and model-run results are not included.

Hugging Face usage

The Dataset Viewer and default dataset configuration expose the 420 model-visible inputs from data/prompts.jsonl as the test split. The input_set column distinguishes main, evidence, and belief_support; these are evaluation conditions, not training splits.

from datasets import load_dataset

inputs = load_dataset("90879c/llm-collaboration-trustbench", split="test")

To use the runner and scorer, download the complete repository and run the quick-start commands from its root:

pip install -U huggingface_hub
hf download 90879c/llm-collaboration-trustbench --repo-type dataset --local-dir llm-collaboration-trustbench
cd llm-collaboration-trustbench
python -m trust_benchmark validate

Public release scope

This release includes the model-visible prompts and the evaluator's reference answers, full decision trees, feedback draws, and scoring code for reproducibility. The reference material is public; this is not a hidden-answer test set. Only the public prompt and feedback reached during the interaction should be supplied to the evaluated model. The supplied runner keeps reference values out of model requests. Loading the prompt table alone does not execute the multi-turn evaluation.

All tasks are explicitly specified simulated collaboration scenarios. References to confidential files, privacy, or other sensitive situations describe the simulated task rather than private records.