UTSCybeR/6G-JEV

RANIntent v1

RANIntent v1 is a benchmark of natural-language intents for an O-RAN network. Each intent is paired with the A1 policy it expresses and with a KPM telemetry table that holds the network state. It was built for the paper

Intent Interpretation at RIC Timescales: Jev Decision Models versus Large Language Models in 6G Open RAN Delong Li, Xu Wang, Haochen Gong, Rui Lang, and Guangsheng Yu. University of Technology Sydney. arXiv: 2609.23136

Code, evaluation harness, and reproduction instructions: https://github.com/OniReimu/6G-JEV

This dataset repository holds the benchmark, the analysis results that the paper's numbers, figures, and tables are computed from, and the raw run records the results are computed from. Apart from runs/, the directory layout is identical to the GitHub repository, so the files can be dropped into a clone of the code.

The task

An interpreter reads the issuer, the intent text, and the telemetry table, and returns one policy of A1 policy type 20001 with 9 fields, each set to one allowed value (data/ranbench/ranintent-v1/schemas/ranintent_v1_policy_type.json):

Field	Values
action	prioritise, deprioritise, guarantee_share, cap_share, restrict_edge, relax_edge, set_latency_target, revert_default, unsupported
class	emergency_video, mission_voice, factory_control, xr_gaming, video_streaming, iot_metering, analytics_offload, best_effort
scope	all_cells, north_cluster, south_cluster, stadium, hospital_zone, most_loaded_cells, worst_edge_cells, unspecified
target_cluster	north_cluster, south_cluster, stadium, hospital_zone, none
priority	critical, high, normal, low, unspecified
prb_share	10, 20, 30, 50, 70, unspecified
edge_site	on_site, metro_edge, regional_cloud, any, unspecified
latency_target	5, 10, 20, 50, 100, unspecified
duration	until_revoked, 15min, 1h, event_end, unspecified

The reading rules given to every interpreter and to the verifier are in data/ranbench/ranintent-v1/schemas/ranintent_v1_reading_rules.md. In a state-dependent case the scope is most_loaded_cells or worst_edge_cells, the text names no cluster, and target_cluster is the cluster that contains the extreme cell of the telemetry. The rules for stale, noisy, and contradictory telemetry decide which rows count. The paper scores accuracy on target_cluster, the match of the actuated fields (action, class, scope, priority), full-policy match, schema validity, and unsafe policies.

Conditions

There are 16 conditions (one dataset config each). They share one set of label tuples and one intent text per tuple, and differ only in the attached telemetry: 3, 7, 21, 57 cells, each fresh, stale, noisy, contradictory. Each condition has a test split and a dev split. The last column is the median cl100k_base token count of the telemetry table in the test split.

Config	Cells	Telemetry	Test	Dev	Telemetry tokens (median)
c3_fresh	3	fresh	300	60	117
c3_stale	3	stale	300	60	273
c3_noisy	3	noisy	300	60	157
c3_contradictory	3	contradictory	300	60	208
c7_fresh	7	fresh	300	60	208
c7_stale	7	stale	300	60	567
c7_noisy	7	noisy	300	60	248
c7_contradictory	7	contradictory	300	60	418
c21_fresh	21	fresh	300	60	527
c21_stale	21	stale	300	60	1597
c21_noisy	21	noisy	300	60	567
c21_contradictory	21	contradictory	300	60	1154
c57_fresh	57	fresh	300	60	1346
c57_stale	57	stale	300	60	4243
c57_noisy	57	noisy	300	60	1386
c57_contradictory	57	contradictory	300	60	3044

In every condition, 150 test cases are state-dependent and 150 name their cluster (30 and 30 in dev). Development cases are meant only for prompt checks.

from datasets import load_dataset
ds = load_dataset("OniReimu/6G-JEV", "c21_fresh")      # splits: test, dev

Case format

The first test case of c57_fresh, with the telemetry table truncated and the issuer and meta fields shortened:

{
 "case_id": "ranintent_v1_test_0000",
 "condition": "c57_fresh",
 "n_cells": 57,
 "quality": "fresh",
 "split": "test",
 "half": "state_dependent",
 "issuer": {
  "id": "operator",
  "kind": "operator"
 },
 "text": "Trouble Ticket: Configure an end-to-end latency threshold of 10 ms for sensor and meter reporting data on cells where boundary user throughput is minimal.",
 "telemetry": "KPM telemetry snapshot at 2026-10-03T18:36:39Z; 57 cells\ncell_id,cluster,prb_util_pct,dl_thr_mbps,p95_delay_ms,edge_ue_thr_mbps\ncell-100,hospital_zone,67.5,470. [truncated]",
 "truth": {
  "action": "set_latency_target",
  "class": "iot_metering",
  "scope": "worst_edge_cells",
  "target_cluster": "hospital_zone",
  "priority": "unspecified",
  "prb_share": "unspecified",
  "edge_site": "unspecified",
  "latency_target": "10",
  "duration": "unspecified"
 },
 "meta": {
  "wording_family": "operator ticket"
 }
}

• issuer: the operator, or a tenant with the traffic classes it owns and whether it may set critical priority.
• telemetry: the KPM table, one or more rows per radio cell, each row naming its cell's cluster.
• truth: the policy, one value per field.
• meta: wording family, generator, verifier, and generation details.

How the cases were made

1. Label tuples were sampled first, with balanced marginals per field (300 test and 60 development tuples, seed 20260925).
2. A generator model (Gemini-3.8-Flash) wrote one intent text per tuple in one of 6 wording families (NOC chat message, email, exposure API request note, formal SLA clause, operator ticket, voice-assistant utterance).
3. A blind verifier (Claude-Opus-5.5, in a separate session) labelled each text with its telemetry table, without seeing the tuple, using the same reading rules the interpreters get. A case was kept only when its labels matched the tuple on every field. Lint checks rejected texts that name a cluster in a state-dependent case or contain field names or option identifiers. Of 365 generated texts, 360 passed the lints and 360 were accepted. 296 of the 300 test tuples were accepted with their first text.
4. The telemetry tables of all conditions were built programmatically around two extreme cells per tuple, so the target cluster is the same at every telemetry size.

The operator issues 175 of the 300 test intents and 40 of the 60 development intents. 4 tenants issue the rest (test: civic_safety 38, lumen_media 38, axis_robotics 32, datacrest 17. Dev: civic_safety 9, datacrest 4, lumen_media 4, axis_robotics 3). The generator and verifier of every case are in meta.generator and meta.verifier and in manifest.json. Neither model is among the interpreters the paper evaluates.

Other files

Path	Content
data/ranbench/ranintent-v1/RQ4/	The 16 conditions, test.jsonl and dev.jsonl each
data/ranbench/ranintent-v1/tuples/, _tuples/	The label tuples of both splits, and the sampled tuples before text generation
data/ranbench/ranintent-v1/pool/c2c3_pool.jsonl	The 150 named-scope test intents of c21_fresh that the radio simulation and the real stack draw from
data/ranbench/ranintent-v1/schemas/	The A1 policy type, the truth schema, and the reading rules
data/ranbench/ranintent-v1/config.json, manifest.json, provenance.json, stats.json, README.md	Generation settings, generator and verifier with yields and file hashes, assembly record, telemetry statistics, and a description
experiments/c1-interpretation/results/	Interpretation layer: accuracy, validity, latency, fees, and energy per interpreter and condition, near-RT feasibility, hypothesis H3, the per-call ledger fields of the latency distribution, and the RQ3 load traces
experiments/c2-closed-loop/results/	Closed-loop radio simulation: controls, latency-only contrasts and hypotheses H1 and H2, radio KPIs, the RQ3 and RQ5 results, the run matrix, and the per-run selection
experiments/c3-real-stack/results/	Real A1 and E2 control path: path decomposition and per-intent records
runs/	Raw run records (see below and runs/README.md)
LICENSE	CC BY 4.0
.gitattributes	Git LFS patterns

Raw run records

runs/ holds 8,943 record files (19.8 GB), the raw per-call and per-run records that experiments/*/results/ is computed from. In a clone of the GitHub repository with the Quick start environment, the commands below rerun the C1, RQ3, C3, and C2 analyses without API keys, GPUs, or a simulator, from the repository root. The latency summaries and path samples next to them are rebuilt by scripts/paper_assets.py, as in the Quick start:

Folder	Content	Files	Size
runs/c1/	The 11 C1 run directories the C1 analysis reads (35,331 ledger rows, RTT probes, GPU power traces, AnyJev-L0 case orders) and the gap-fill case lists	199	158 MB
runs/rq3-load-traces/	Every RQ3 load-trace block of every session (55 blocks: trace, ledger, integrity report), including the earlier AnyJev-L0 sessions kept as audit records	184	86 MB
runs/c3-real-stack/	The 7 C3 main runs (records, A1 log, xApp log, iperf3 trace, integrity report, driver log, gzip-compressed gNB log) and the tunnel round-trip times	52	374 MB
runs/c2-runs/	The 316 C2 runs selected in selection.csv, the 8 RQ5 references, and the 18 layout replicates of the robustness check, each under its platform root	6,519	19.2 GB
runs/c2-inputs/	The run matrices, input manifests, intent streams, enforcement schedules, and radio configurations of the three C2 input trees	1,981	41 MB
runs/c2-records/	The C1 decisions of the pool intents that the C2 schedules were built from	8	402 kB

uv pip install huggingface_hub
uv run hf download OniReimu/6G-JEV --repo-type dataset --include "runs/*" --local-dir .

# C1: rebuild the interpretation-layer analysis and compare it with the released files
uv run python scripts/rb_c1_analyze.py --corpus data/ranbench/ranintent-v1 --out out/c1 \
    --runs runs/c1/c1_hosted runs/c1/c1_selfhosted runs/c1/c1_rerun \
           runs/c1/c1_hosted_qwen_block2 runs/c1/c1_hosted_qwen_block3 runs/c1/c1_hosted_qwen_gapfill1 \
           runs/c1/c1_hosted_qwen_gapfill2 runs/c1/c1_hosted_qwen_gapfill3 runs/c1/c1_hosted_qwen_gapfill4 \
           runs/c1/c1_hosted_qwen_gapfill5 runs/c1/c1_hosted_qwen_gapfill6
for f in out/c1/*; do cmp "$f" "experiments/c1-interpretation/results/$(basename "$f")"; done

# RQ3 and C3: the raw traces and records go where the release keeps the primary ones, and the tables are rebuilt
rsync -a runs/rq3-load-traces/ experiments/c1-interpretation/results/rq3-load/traces/
rsync -a runs/c3-real-stack/ experiments/c3-real-stack/results/runs/
uv run python scripts/c3_rq3_analysis.py
git diff --stat                    # prints nothing when the rebuilt tables are byte-identical

# C2: select one copy per run as the paper did, then rerun the analysis (it reads the RQ3 traces placed above)
ln -s runs/c2-runs c2-runs && ln -s runs/c2-inputs c2-inputs && ln -s runs/c2-records c2-records
MATRIX=experiments/c2-closed-loop/results/run-matrix.csv
SELECT_ARGS=()
while IFS= read -r arg; do SELECT_ARGS+=("$arg"); done < <(uv run python -c '
import csv
rows = list(csv.DictReader(open("experiments/c2-closed-loop/results/selection.csv")))
for kind, flag in (("original", "--original-root"), ("rerun", "--rerun-root")):
    for root in sorted({r["chosen_root"] for r in rows if r["kind"] == kind}):
        print(flag); print(root)
for r in rows:
    if r["chosen_root"] and "EXCLUDED" in r["other_copies"]:
        print("--restrict"); print(r["run_id"] + "=" + r["chosen_root"])')
uv run python -m src.ranbench.c2.select_runs --matrix "$MATRIX" "${SELECT_ARGS[@]}" --out c2-selected --force
uv run python -m src.ranbench.c2.analysis --matrix "$MATRIX" --runs-root c2-selected --out out/c2 \
    --rq5-refs-root c2-runs/rq5-refs-m4
sed "s#$(pwd -P)/runs/##" out/c2/runs.csv > out/c2/runs.rel.csv && mv out/c2/runs.rel.csv out/c2/runs.csv
diff -r out/c2 experiments/c2-closed-loop/results/analysis      # prints nothing

Every C1 file, the three RQ3 and C3 tables, and every file of the C2 analysis directory come out byte-identical to the released ones. The one adjustment is the platform_root column of runs.csv, which the analysis writes as the absolute path of each run directory on the machine that runs it, so the sed line removes the local prefix first. c2-selected/selection.csv names the same copy, binary, and completion time for every run as experiments/c2-closed-loop/results/selection.csv, but its reason and other_copies columns only see the copies shipped here.

runs/README.md describes every file.

Limitations

The intent texts were written and verified by language models, so their wording may favor phrasing that such models parse easily. The blind agreement filter and the reading rules shared by the verifier and the interpreters limit this effect. All texts are in English, and the network, tenants, and telemetry are synthetic.

License

CC BY 4.0. The code in the GitHub repository is under the MIT license, except the simulator patches, which are GPL-2.0-only like the 5G-LENA code they modify.