---
license: other
language:
- en
pretty_name: "RoleRouteBench: A Reproducible Multi-Domain Environment for Evaluating Dynamic Multi-Agent Routing"
annotations_creators:
- expert-generated
multilinguality:
- monolingual
source_datasets:
- extended
size_categories:
- 1K<n<10K
tags:
- multi-agent
- multi-agent-systems
- agent-routing
- llm-routing
- slm
- orchestration
- dynamic-routing
- live-trajectories
- tool-use
- agent-evaluation
- benchmark
- datasets
- text
- tabular
- code-debugging
- formal-proof
- database-migration
- spreadsheet
configs:
- config_name: router_state
  default: true
  data_files:
  - split: development
    path: data/router_state/development.parquet
  - split: validation
    path: data/router_state/validation.parquet
  - split: test
    path: data/router_state/test.parquet
- config_name: router_structured
  data_files:
  - split: development
    path: data/router_structured/development.parquet
  - split: validation
    path: data/router_structured/validation.parquet
  - split: test
    path: data/router_structured/test.parquet
- config_name: router_raw_development
  data_files:
  - split: development
    path: data/router_raw_development/development.parquet
- config_name: track_a_labels
  data_files:
  - split: development
    path: data/track_a_labels/development.parquet
  - split: validation
    path: data/track_a_labels/validation.parquet
  - split: test
    path: data/track_a_labels/test.parquet
- config_name: agent_catalog
  data_files:
  - split: train
    path: data/agent_catalog/train.parquet
- config_name: provenance
  data_files:
  - split: development
    path: data/provenance/development.parquet
  - split: validation
    path: data/provenance/validation.parquet
  - split: test
    path: data/provenance/test.parquet
- config_name: human_review
  data_files:
  - split: development
    path: data/human_review/development.parquet
  - split: validation
    path: data/human_review/validation.parquet
  - split: test
    path: data/human_review/test.parquet
- config_name: track_b_tasks
  data_files:
  - split: full
    path: data/track_b_tasks/full.parquet
- config_name: track_b_agents
  data_files:
  - split: full
    path: data/track_b_agents/full.parquet
- config_name: track_b_trajectories
  data_files:
  - split: full
    path: data/track_b_trajectories/full.parquet
- config_name: track_b_results
  data_files:
  - split: full
    path: data/track_b_results/full.parquet
- config_name: track_b_runs
  data_files:
  - split: full
    path: data/track_b_runs/full.parquet
- config_name: track_b_provenance
  data_files:
  - split: full
    path: data/track_b_provenance/full.parquet
---

# RoleRouteBench: A Reproducible Multi-Domain Environment for Evaluating Dynamic Multi-Agent Routing

RoleRouteBench was previously released under the development name “RoutingBench V4-beta.” The benchmark design, frozen runtime, packet identifiers, and historical revisions are unchanged.

RoutingBench is a benchmark for **LLM/decision-model routing**, **multi-agent
orchestration**, and coordination of **small language model (SLM) or
deterministic executors** on multi-step tasks. A router observes the public
state, selects one role or `STOP`, and receives the observable consequence of
that action. The environment preserves action consequences, separates
router-visible artifacts from evaluator-only artifacts, and reports routing
behavior separately from final task correctness.

This is **version 4.0.0-beta.2**. It keeps Track A unchanged and replaces the
earlier simulated Track B export with 82 live trajectories from four task
domains. Track C is temporarily absent from this revision.

## Release scope

| Track | Status in beta.2 | Unit | Split policy |
|---|---|---|---|
| Track A | Unchanged from beta.1 | Isolated next-agent decision | Existing `development` / `validation` / `test` splits |
| Track B | Updated | Full live multi-agent trajectory | One public `full` split; no holdout |
| Track C | Temporarily removed | Checkpointed recovery | Will return in a later revision |

The next planned update will revise Track A, restore Track C, and add four more
Track B domains. This beta is a transparent research benchmark, not a sealed
leaderboard.

## Reproducible release

The frozen beta.2 code and dataset are identified independently. Report both
revisions in every experiment:

- **GitHub tag:** [`routingbench-v4-beta.2`](https://github.com/BuiThiThanhTrang/RACO_MAS/tree/routingbench-v4-beta.2)
- **Code commit:** [`ee21943c3594c97f51f2082d0671dde44b7d2eb2`](https://github.com/BuiThiThanhTrang/RACO_MAS/commit/ee21943c3594c97f51f2082d0671dde44b7d2eb2)
- **Dataset revision:** [`cdc67bad1458f6b939f759e3f764f2e93612f424`](https://huggingface.co/datasets/TrangBui/RoutingBench-V4/tree/cdc67bad1458f6b939f759e3f764f2e93612f424)

The following PowerShell commands reproduce the release certificate from a
clean checkout on Windows with Python 3.13:

```powershell
git clone --branch routingbench-v4-beta.2 --depth 1 `
  https://github.com/BuiThiThanhTrang/RACO_MAS.git
cd RACO_MAS\puppeteer

py -3.13 -m venv .venv
.\.venv\Scripts\Activate.ps1
python -m pip install --upgrade pip
python -m pip install -r requirements-routingbench-v4-release.lock.txt

python scripts\download_routingbench_v4.py `
  --repo-id TrangBui/RoutingBench-V4 `
  --revision cdc67bad1458f6b939f759e3f764f2e93612f424 `
  --output data\RoutingBench\v4_beta_4d_82_20261102

python -m unittest tests.test_routingbench_v4_private_isolation -v
python scripts\certify_routingbench_v4_release.py `
  --release-root data\RoutingBench\v4_beta_4d_82_20261102 `
  --runtime-manifest reproducibility\runtime_core.sha256.json `
  --report reproducibility\certification_report.json
```

The clean-clone certificate validates 94 frozen runtime files with aggregate
SHA-256 `779cfc4d9e913c26b8145f7435a983cd200771465707f54360fdec15ece2f16e`,
all 82 Track B packets, and 732 router/executor model contexts.

## Tracks

### Track A — isolated routing

Track A asks a model to choose the next agent from an isolated observable state.
It contains 2,604 decisions derived from 124 base workflows. The router-facing
views are `router_state`, `router_structured`, and development-only
`router_raw_development`; labels are stored separately in `track_a_labels`.

The Track A data and split assignment are byte-for-byte inherited from beta.1.
Its existing human-review records remain pending unless a row states otherwise.

### Track B — live multi-step coordination

Track B runs the complete router–executor loop. Every action is executed through
the domain adapter, its observable consequence is added to state, and the router
chooses again until `STOP` or the call budget terminates the episode.

| Domain | Packets | Core task | Executor backbone | Packet human review |
|---|---:|---|---|---|
| Database migration and integrity | 12 | Plan, implement, execute, and verify schema/data migrations | Qwen3.5-9B | Complete |
| Code debugging | 20 | Reproduce, diagnose, patch, test, and finalize repository bugs | Gemini 2.5 Flash | Complete |
| Formal proof | 30 | Repair or complete Lean proofs with compiler feedback | Goedel-Prover-V2-8B | Complete |
| Structured data processing | 20 | Transform and validate reusable spreadsheet programs | Qwen3.5-9B | Pending; research preview |

All four published pilots use `typesafe/jev-1.13` as the router. Model/provider
names are provenance, not router input features. The executor pool, adapter,
budget, packet, evaluator, and role cards are frozen within each comparison.

Track B deliberately has no train/test split in this revision. The `full` split
is intended for controlled router comparisons where every competing router sees
the same public packet set and uses the same frozen executor environment.

### Track C — checkpointed recovery

Track C is not included in beta.2. The beta.1 checkpoint tables were removed to
avoid presenting a partially updated recovery track beside the new live Track B.
Track C will be republished after its state contracts and review records are
updated.

## Track B configurations

| Configuration | Rows | Visibility | Purpose |
|---|---:|---|---|
| `track_b_tasks` | 82 | Router/task public | Task, adapter, packet paths, status, and public manifest |
| `track_b_agents` | 33 | Router public | Role cards and role contracts for the four pools |
| `track_b_trajectories` | 82 | Analysis public | Compact decision/event sequences; raw prompts and executor outputs excluded |
| `track_b_results` | 82 | Evaluator only | Terminal outcome, independent task result, budget and routing counts |
| `track_b_runs` | 4 | Analysis public | Domain-level run provenance and headline metrics |
| `track_b_provenance` | 82 | Analysis public | Source revision, record identifier, generator, checksum, and license |

## Agent-pool design

Each domain exposes the complete role pool plus `STOP` at every routing step.
The environment does not prescribe a fixed role order or a single workflow.
Role cards define a bounded implementation contract through `role_goal`,
`use_when`, `avoid_when`, supported inputs, tools, and expected outputs; they do
not tell the router which role must be selected next. The router may revisit a
role, skip a role, branch after new evidence, recover from failure, or stop.

The pools intentionally separate evidence collection, artifact authoring,
execution, diagnosis, repair, and verification. This creates alternative valid
workflows while preserving role accountability: an inspector cannot claim an
execution result, an author cannot claim validation, and a verifier evaluates
the current artifact rather than silently replacing it.

### Database migration and integrity — 10 roles

| Role | Contract boundary |
|---|---|
| Schema Inspector | Materialize schema, index, trigger, foreign-key, and migration-history evidence without mutation. |
| Data Profiler | Measure nulls, duplicates, orphan rows, types, and distributions relevant to migration safety. |
| Constraint Analyzer | Analyze invariants and concrete foreign-key, uniqueness, or check-constraint failures. |
| Migration Planner | Plan operation ordering, transaction boundaries, and rollback boundaries from visible evidence. |
| Data Repair Planner | Design the smallest justified backfill, deduplication, remapping, or orphan repair. |
| SQL Migration Author | Produce the smallest evidence-grounded SQLite migration candidate; does not execute it. |
| Transactional Dry-run Executor | Execute the current candidate on an isolated copy and preserve its trace and consequences. |
| Integrity Validator | Check target schema, invariants, rows, foreign keys, and regression queries on the executed artifact. |
| Query Performance Auditor | Inspect query plans or explicit performance constraints when the task requires them. |
| Snapshot & Rollback Operator | Create or restore explicit database snapshots; recovery remains an observable routed action. |

Possible trajectories include direct inspect–author–execute–validate, a
profile/constraint branch before authoring, data-repair planning, repeated
author–dry-run–diagnose cycles, performance audit, or explicit snapshot recovery.

### Code debugging — 6 roles

| Role | Contract boundary |
|---|---|
| Repository Test Reproducer | Prepare the pinned checkout and establish a fresh baseline with the supplied reproducer. |
| Failure Diagnostician | Explain a concrete failure mechanism from execution or repair evidence without changing source. |
| Patch Author | Produce the smallest justified unified diff from visible source, tests, and diagnostics. |
| Regression Verifier | Run the public regression contract against the exact current candidate. |
| Verified Patch Consumer | Promote an exactly verified candidate into the downstream workflow artifact when packaging is needed. |
| Patch Finalizer | Commit the verified downstream patch as the final deliverable after all visible requirements are satisfied. |

The router can choose reproduction before diagnosis, diagnose after a failed
patch, iterate patch and verification, or omit optional packaging roles when the
task contract does not require them. Promotion and finalization cannot substitute
for fresh regression evidence.

### Formal proof — 7 roles

| Role | Contract boundary |
|---|---|
| Proof State Inspector | Read the Lean goal, hypotheses, source, and compiler diagnostics without editing the proof. |
| Premise and Lemma Retriever | Identify applicable visible hypotheses and Mathlib lemmas without claiming compilation. |
| Tactic Synthesizer | Construct a candidate Lean proof from the current goal and evidence. |
| Proof Repair Specialist | Revise a failed candidate using the latest compiler diagnostic while preserving the theorem statement. |
| Lean Compiler Executor | Compile the current candidate in the pinned Lean/Mathlib environment. |
| Kernel and Assumption Verifier | Confirm closure without `sorry`, `admit`, forbidden placeholders, or added assumptions. |
| Formal Failure Diagnostician | Explain concrete compiler/proof failures and derive repair constraints. |

Valid workflows may retrieve lemmas before synthesis, synthesize directly from
the goal, diagnose after compilation, perform several repair–compile cycles, or
verify immediately after a clean compile. Compilation and kernel/assumption
verification remain separate evidence stages.

### Structured data processing — 10 roles

| Role | Contract boundary |
|---|---|
| Workbook Surveyor | Inspect sheets, dimensions, values, formulas, and styles without modifying the input. |
| Data Quality Profiler | Measure missing values, row types, key multiplicity, and other transformation-relevant properties. |
| Formula Dependency Analyst | Inspect formulas and dependencies that may be affected by workbook changes. |
| Table Reshaping Specialist | Author reusable grouping, filtering, joining, sorting, or reshaping transformations. |
| Formula Computation Specialist | Author reusable transformations dominated by formulas or calculated-field semantics. |
| Cross-sheet Reconciler | Reconcile identifiers or values across sheets while preserving unrelated content. |
| Formatting & Presentation Specialist | Implement styles, number formats, layout, or presentation requirements. |
| Workbook Repair Specialist | Revise a failed candidate from concrete public execution or validation evidence. |
| Workbook Test Executor | Run the current candidate in the restricted Python/OpenPyXL public runner. |
| Workbook Integrity Validator | Check a fresh public output against deterministic transformation and preservation constraints. |

Task archetypes—aggregation, cleaning, formatting, formula/dependency, and
reshape/join—activate different authoring roles. The router can survey or profile
first, combine cross-sheet and formula analysis, test early, repair after either
execution or semantic validation failure, and decide when a fresh validation is
sufficient for `STOP`.

The runnable packet trees are under:

```text
track_b_packets/<domain>/<packet_id>/
├── manifest.json
├── public/       # router/executor-visible task artifacts
├── fixtures/     # pinned source/provenance fixtures
└── private/      # evaluator-only reference and oracle material
```

This is a transparent public beta: private reference proofs, gold patches,
answer workbooks, and oracle files are downloadable, but **evaluator-only**.
Their visibility label is a benchmark protocol boundary, not repository access
control. Never pass `private/`, `track_b_results`, or Track A label rows to the
router.

## Loading

```python
from datasets import load_dataset

# Track A: unchanged isolated routing benchmark
track_a_state = load_dataset("TrangBui/RoutingBench-V4", "router_state")
track_a_labels = load_dataset("TrangBui/RoutingBench-V4", "track_a_labels")

# Track B: four live domains, one full split
tasks = load_dataset("TrangBui/RoutingBench-V4", "track_b_tasks", split="full")
agents = load_dataset("TrangBui/RoutingBench-V4", "track_b_agents", split="full")
trajectories = load_dataset(
    "TrangBui/RoutingBench-V4", "track_b_trajectories", split="full"
)
results = load_dataset("TrangBui/RoutingBench-V4", "track_b_results", split="full")
```

JSON-valued columns are stored as JSON strings so the schemas remain stable
across domains. Decode them with `json.loads`.

## Evaluation protocol

For a router comparison:

1. select a Track B domain and freeze its packet revision, role cards, adapter,
   executor model, executor decoding parameters, call budget, and evaluator;
2. expose only the packet's `public/` artifacts and the full role pool plus
   `STOP` to the router;
3. execute every selected action and retain its observable consequence, including
   failed or invalid actions;
4. stop on router `STOP` or budget termination; a decision suppressed at zero
   remaining budget is retained in the raw trace but excluded from primary
   routing decisions;
5. run the independent evaluator on the final state; and
6. report outcome, coordination, safety, and efficiency metrics separately.

Do not automatically roll back failed actions merely to improve the trajectory.
A domain transaction may roll back according to its execution contract, but an
orchestrator-level recovery is a new routed action and must remain observable.

### Required reporting

At minimum, report:

- packet completion and infrastructure-affected episode count;
- trajectory success (`STOP` plus terminal public contract);
- independent end-task success;
- primary and raw router-decision counts;
- budget-suppressed decisions;
- agent/role usage and transitions;
- executor outcomes (`success`, `invalid_output`, `failed`, precondition reject);
- task-specific partial progress; and
- whether valid-action labels were available.

There is no weighted composite score in this release. In particular, final task
success is not a pure router-accuracy measure: it also depends on the fixed
executor. Compare routers only under the same environment freeze.

## Jev reference results

These numbers are reference-system results, not a claim that Jev is an oracle.
They are included to verify that the environment produces non-trivial routing
and task signals.

| Domain | Packets | Trajectory/public success | Independent trusted success | Primary decisions | Raw decisions | Budget-suppressed |
|---|---:|---:|---:|---:|---:|---:|
| Database migration and integrity | 12 | 6 | 7 | 84 | 90 | 6 |
| Code debugging | 20 | 12 | 12 | 143 | 151 | 8 |
| Formal proof | 30 | 17 | 18 | 185 | 198 | 13 |
| Structured data processing | 20 | 2 | 1 | 156 | 174 | 18 |

For database, code, and formal proof, “trajectory success” means the terminal
public contract passed and the router selected `STOP`; “independent trusted
success” is the evaluator-only final task result. Structured data uses a richer
milestone bundle because its hard-pass outcome has a strong floor effect:

| Structured-data milestone | Jev result |
|---|---:|
| Accepted candidate | 11/20 |
| Public execution succeeded | 6/20 |
| Public validation passed and router selected `STOP` | 2/20 |
| Trusted hard pass | 1/20 |
| Trusted evaluator cases passed | 3/59 |

The structured-data traces still contain survey, authoring, profiling,
cross-sheet work, testing, validation, repair, precondition rejection, missing
`STOP`, and budget exhaustion. They are useful for coordination analysis, but
task success alone has limited power until executor reliability improves.

## Human-review status

Human review is recorded at two different units and must not be conflated:

- **Packet review:** checks task meaning, public/private boundary, contract,
  artifacts, and evaluator suitability. It is complete for database, code
  debugging, and formal proof. Structured-data packet review is still pending.
- **Decision-state review:** labels whether a routed next action is valid at a
  particular live state. These labels are pending for all new Track B domains.

The formal-proof metadata records project-owner approval dated 2026-11-02.
Code-debugging review is supported by the 20-item artifact review queue and a
complete 20-episode live run, so no replacement run was needed for this release.

## Quality controls

- 82/82 Track B packets have a canonical live episode.
- Formal-proof manifests validate after the review update (30/30).
- Public task artifacts and evaluator-only private artifacts are packaged in
  separate directories with explicit visibility boundaries.
- Compact trajectory rows retain routing choices, probabilities, timing,
  budget, dispatch status, event status, and state hashes without publishing raw
  model prompts or outputs.
- The structured-data cohort excludes superseded infrastructure-affected
  episodes and uses the patched replacement runs.
- Source/run identifiers remain attached; historical runs are not relabeled as
  newly executed experiments.

## Known limitations

- Track B has no sealed test split and should not be used for hidden-leaderboard
  claims.
- New Track B live states do not yet have human valid-action labels.
- Structured-data packet human review is pending and its executor creates a
  strong outcome floor.
- Executor backbones differ by domain, so absolute success rates should not be
  compared across domains as if task difficulty were controlled.
- Three code-debugging packets have `NOASSERTION` license metadata; inspect
  `track_b_provenance` before redistribution or derivative packaging.
- Track A review and Track C redesign are not part of beta.2.

## Provenance and licenses

RoutingBench contains project-authored schemas and adapters plus heterogeneous
upstream task material. The repository-level license is therefore `other`.
Use the row-level `license`, source revision, record ID, and checksum in
`track_b_provenance`; Track A provenance remains in `provenance`. The project
license does not replace upstream licenses.

The license boundary is explicit:

- the GitHub harness, adapters, runner, evaluator, CI, and project-authored
  code are released under
  [Apache License 2.0](https://github.com/BuiThiThanhTrang/RACO_MAS/blob/routingbench-v4-beta.2/LICENSE);
- dataset files on this Hugging Face repository are governed by
  [`LICENSE_DATA`](./LICENSE_DATA), including the source-specific terms and
  provenance it references;
- bundled third-party materials retain their original licenses.

Reference implementation:
[BuiThiThanhTrang/RACO_MAS](https://github.com/BuiThiThanhTrang/RACO_MAS)

## Authors and contributors

- **Trang Bui** — dataset creator, benchmark and environment designer, release
  maintainer, and author of the current four-domain beta release.
- **Tran Ngoc Cam Nguyen** — planned domain lead for **Multi-hop Knowledge** and
  **Document/Media**.


## Roadmap

A later revision is planned to:

- update and review Track A;
- restore the redesigned Track C recovery benchmark;
- finish structured-data human review; and
- add four additional Track B domains to reach the planned eight-domain suite,
  including Multi-hop Knowledge and Document/Media led by Tran Ngoc Cam Nguyen.

## Citation

```bibtex
@dataset{bui2026routingbenchv4,
  author    = {Trang Bui},
  title     = {RoutingBench V4-beta: Dynamic Multi-Agent Routing with Live Trajectories},
  year      = {2026},
  version   = {4.0.0-beta.2},
  publisher = {Hugging Face},
  url       = {https://huggingface.co/datasets/TrangBui/RoutingBench-V4}
}
```

This citation describes `4.0.0-beta.2`. A future release containing the planned
Multi-hop Knowledge and Document/Media domains will receive a new DOI and an
updated author list.