Datasets:

sajjadanwar0
/

sbus-benchmarks

license: cc-by-4.0
language:
  - en
task_categories:
  - text-classification
tags:
  - multi-agent
  - concurrency
  - inter-annotator-agreement
  - human-evaluation
  - long-horizon-planning
  - benchmark
  - llm-agents
size_categories:
  - n<1K
pretty_name: S-Bus Benchmarks and PH-3 Human Annotations
arxiv: 2605.17076
configs:
  - config_name: long_horizon_tasks
    data_files:
      - split: lhp_15
        path: data/long_horizon_tasks/long_horizon_tasks.json
      - split: multidomain_30
        path: data/long_horizon_tasks/tasks_30_multidomain.json
  - config_name: ph3_human_annotations
    data_files:
      - split: annotator_1
        path: data/ph3_human_annotations/annotator_1.csv
      - split: annotator_2
        path: data/ph3_human_annotations/annotator_2.csv

S-Bus: Long-Horizon Planning Benchmarks and PH-3 Human Annotations

Companion datasets for the paper Reliable Autonomous Orchestration: A Rust-Based Transactional Middleware for Mitigating Semantic Synchronization Overhead in Multi-Agent Systems (Khan, 2026).

arXiv: https://arxiv.org/abs/2605.17076
Code (S-Bus server): https://github.com/sajjadanwar0/sbus
Code (experiments): https://github.com/sajjadanwar0/sbus-experiments

Configs

`long_horizon_tasks`

Long-horizon planning benchmarks used to evaluate S-Bus against LangGraph, CrewAI, and AutoGen.

Split	Tasks	Step range	Description
`lhp_15`	15	20-40	Original LHP benchmark across 7 domains: software architecture, security and compliance, data and ML pipelines, codebase refactoring, system design, research synthesis, product and API design.
`multidomain_30`	30	varies	Extended 30-task multi-domain set.

from datasets import load_dataset
ds = load_dataset("sajjadanwar0/sbus-benchmarks", "long_horizon_tasks", split="lhp_15")

`ph3_human_annotations`

Two independent human annotators labeled 400 (session, candidate-shard) pairs sampled from S-Bus evaluation runs. For each pair the annotator judged whether the agent's action genuinely used the candidate shard, given what the agent itself claimed in its self-report.

The source 400 tasks are available as source_tasks.json in the repository file tree, along with the annotation web tool (annotation_tool/annotator.html) and protocol (annotation_tool/GUIDE.md) so the study can be reproduced or extended by independent annotators.

Schema

Column	Type	Description
`row_idx`	int	Zero-indexed row identifier. Shared across both rater files.
`candidate_shard`	str	The S-Bus shard whose use is being judged (e.g., `migration_plan`, `models_state`, `view_logic`, `permission_check`, `action_registry`).
`human_label`	str	One of `yes`, `no`, `unclear`. The rater's judgment of whether the shard was genuinely used.
`agent_said_used_it`	str	`yes` or `no` — what the agent itself claimed in its output. The cue the rater scored against.

Inter-rater agreement

Cohen's κ is reported under two regimes because 307 of 400 rows have at least one unclear label, making a 3-class report and a 2-class (committed) report tell different stories.

Regime	n	Cohen's κ	Landis & Koch	Raw agreement
Strict (yes/no only)	93	0.931	almost perfect	96.8%
Lenient (3-class with `unclear`)	400	0.695	substantial	—

Strict confusion matrix:

	rater 2: yes	rater 2: no
rater 1: yes	33	0
rater 1: no	3	57

Interpretation. When raters commit to a definite yes/no, they near-perfectly agree (κ=0.931). The substantial volume of unclear labels — 77% of rows had at least one — is itself the headline finding: attributing shard usage from agent traces is genuinely ambiguous even for trained humans. This motivates not relying on agent self-report and is the empirical case for the SCR detection mechanism in S-Bus.

Reproducing these figures

The scoring script is bundled in the repository under scripts/:

python3 scripts/score_annotations.py \
    data/ph3_human_annotations/annotator_1.csv \
    data/ph3_human_annotations/annotator_2.csv

Or using datasets directly:

import pandas as pd
from datasets import load_dataset
from sklearn.metrics import cohen_kappa_score

ds = load_dataset("sajjadanwar0/sbus-benchmarks", "ph3_human_annotations")
a1 = ds["annotator_1"].to_pandas()
a2 = ds["annotator_2"].to_pandas()
m = a1.merge(a2, on=["row_idx", "candidate_shard"], suffixes=("_r1", "_r2"))

# Lenient (3-class with unclear)
print("Lenient kappa:", cohen_kappa_score(m["human_label_r1"], m["human_label_r2"]))

# Strict (yes/no committed only)
strict = m[m["human_label_r1"].isin(["yes", "no"]) &
           m["human_label_r2"].isin(["yes", "no"])]
print("Strict kappa: ", cohen_kappa_score(strict["human_label_r1"], strict["human_label_r2"]))

Agent self-report validity

Comparing each annotator's labels against agent_said_used_it shows the agents systematically over-claim shard usage:

Annotator	n	Precision	Recall	Accuracy
Rater 1	96	0.681	0.941	0.823
Rater 2	144	0.514	0.725	0.660

When an agent claims to have used a shard, 32-49% of those claims are disputed by the human raters (precision 0.51-0.68). When raters mark a shard as truly used, agents catch it 73-94% of the time. This precision gap is the empirical motivation for transactional shard tracking rather than trusting agent self-report.

Citation

@article{khan2026sbus,
  title   = {Reliable Autonomous Orchestration: A Rust-Based Transactional
             Middleware for Mitigating Semantic Synchronization Overhead
             in Multi-Agent Systems},
  author  = {Khan, Sajjad},
  journal = {arXiv preprint arXiv:2605.17076},
  year    = {2026}
}

License

CC-BY-4.0 for all data, scripts, and annotation materials in this repository.

Repository structure

sbus-benchmarks/
├── README.md                    # this file
├── LICENSE                      # CC-BY-4.0
├── data/
│   ├── long_horizon_tasks/
│   │   ├── long_horizon_tasks.json
│   │   └── tasks_30_multidomain.json
│   └── ph3_human_annotations/
│       ├── annotator_1.csv      # rater 1 labels (400 rows)
│       ├── annotator_2.csv      # rater 2 labels (400 rows)
│       └── source_tasks.json    # the 400 (session, shard) pairs annotated
├── annotation_tool/
│   ├── annotator.html           # browser-based annotation UI
│   └── GUIDE.md                 # annotation protocol and rubric
└── scripts/
    └── score_annotations.py     # Cohen's kappa + self-report stats

Contact

Sajjad Khan — https://github.com/sajjadanwar0