Dataset Viewer
Auto-converted to Parquet Duplicate
id
stringlengths
6
8
type
stringclasses
8 values
answer
stringclasses
4 values
options
stringclasses
3 values
probs
listlengths
2
4
pred
stringclasses
4 values
n_images
int64
1
16
n_tokens
int64
63
2.99k
latency_s
float64
0.26
147
ERQA_1
Trajectory Reasoning
A
ABCD
[ 0.02699, 0.89385, 0.0445, 0.03466 ]
B
1
186
146.56
ERQA_2
Action Reasoning
B
ABCD
[ 0.34296, 0.499, 0.14297, 0.01507 ]
B
1
177
1.77
ERQA_3
Action Reasoning
A
ABCD
[ 0.6137, 0.37223, 0.00682, 0.00726 ]
A
1
258
1.31
ERQA_4
Trajectory Reasoning
A
ABCD
[ 0.37461, 0.15616, 0.42449, 0.04474 ]
C
1
180
1.32
ERQA_5
Pointing
D
ABCD
[ 0.10054, 0.74287, 0.0783, 0.0783 ]
B
1
227
1.85
ERQA_6
Action Reasoning
A
ABCD
[ 0.69837, 0.29112, 0.00685, 0.00366 ]
A
1
286
1.83
ERQA_7
Trajectory Reasoning
B
ABCD
[ 0.44887, 0.03685, 0.50864, 0.00565 ]
C
1
159
1.28
ERQA_8
Action Reasoning
C
ABCD
[ 0.24377, 0.10162, 0.58477, 0.06984 ]
C
1
192
1.39
ERQA_9
Action Reasoning
B
ABCD
[ 0.48824, 0.38025, 0.09614, 0.03537 ]
A
1
273
2.32
ERQA_10
Pointing
C
ABCD
[ 0.24721, 0.28013, 0.28013, 0.19253 ]
B
1
284
2.31
ERQA_11
Trajectory Reasoning
C
ABCD
[ 0.08501, 0.00094, 0.91396, 0.00009 ]
C
1
288
1.83
ERQA_12
Trajectory Reasoning
C
ABCD
[ 0.14477, 0.16405, 0.5053, 0.18589 ]
C
1
188
1.06
ERQA_13
Pointing
B
ABCD
[ 0.26016, 0.48605, 0.22959, 0.0242 ]
B
1
217
0.95
ERQA_14
State Estimation
D
ABCD
[ 0.00218, 0.00055, 0.00062, 0.99664 ]
D
1
150
1.35
ERQA_15
Trajectory Reasoning
A
ABCD
[ 0.22363, 0.32539, 0.36871, 0.08227 ]
C
1
238
1.39
ERQA_16
Action Reasoning
C
ABCD
[ 0.2295, 0.1392, 0.42876, 0.20253 ]
C
1
249
1.67
ERQA_17
Spatial Reasoning
D
ABCD
[ 0.07779, 0.05346, 0.03243, 0.83632 ]
D
1
221
6.5
ERQA_18
Trajectory Reasoning
D
ABCD
[ 0.17673, 0.07367, 0.05063, 0.69897 ]
D
1
230
1.58
ERQA_19
Trajectory Reasoning
A
ABCD
[ 0.99986, 0.00004, 0.00008, 0.00001 ]
A
1
265
2.94
ERQA_20
State Estimation
B
ABCD
[ 0.19954, 0.69646, 0.07341, 0.0306 ]
B
1
285
2.35
ERQA_21
Action Reasoning
C
ABCD
[ 0.02421, 0.02743, 0.90844, 0.03991 ]
C
1
264
1.98
ERQA_22
Spatial Reasoning
A
ABCD
[ 0.36535, 0.36535, 0.01819, 0.2511 ]
A
1
148
1.4
ERQA_23
Spatial Reasoning
A
ABCD
[ 0.63256, 0.20536, 0.15994, 0.00214 ]
A
1
217
1.05
ERQA_24
State Estimation
D
ABCD
[ 0.2101, 0.73331, 0.01522, 0.04137 ]
B
1
291
2.14
ERQA_25
State Estimation
B
AB
[ 0.18243, 0.81757 ]
B
1
243
5.9
ERQA_26
Action Reasoning
B
ABCD
[ 0.17528, 0.37107, 0.25503, 0.19862 ]
B
1
180
0.79
ERQA_27
Action Reasoning
A
ABCD
[ 0.32107, 0.59983, 0.04924, 0.02986 ]
B
1
271
1.51
ERQA_28
Trajectory Reasoning
A
ABCD
[ 0.90586, 0.02735, 0.05791, 0.00888 ]
A
1
250
1.25
ERQA_29
Spatial Reasoning
B
ABCD
[ 0.00214, 0.97781, 0.01791, 0.00214 ]
B
1
252
1.82
ERQA_30
Trajectory Reasoning
D
ABCD
[ 0.4087, 0.24789, 0.15035, 0.19306 ]
A
1
208
0.94
ERQA_31
Action Reasoning
D
ABCD
[ 0.03923, 0.3285, 0.61373, 0.01853 ]
C
1
159
0.86
ERQA_32
State Estimation
A
AB
[ 0.98594, 0.01406 ]
A
1
240
5.8
ERQA_33
Action Reasoning
C
ABCD
[ 0.39564, 0.27192, 0.18689, 0.14555 ]
A
1
305
1.64
ERQA_34
Action Reasoning
B
ABCD
[ 0.23745, 0.30489, 0.34549, 0.11216 ]
C
1
276
1.95
ERQA_35
Spatial Reasoning
B
ABCD
[ 0.15694, 0.1385, 0.70336, 0.0012 ]
C
1
180
0.78
ERQA_36
Spatial Reasoning
D
ABCD
[ 0.40852, 0.19297, 0.36052, 0.038 ]
A
1
285
1.71
ERQA_37
Pointing
B
ABCD
[ 0.1504, 0.36079, 0.17042, 0.31839 ]
B
1
223
2.48
ERQA_38
Action Reasoning
C
ABCD
[ 0.79593, 0.07403, 0.09506, 0.03497 ]
A
1
271
1.64
ERQA_39
State Estimation
A
AB
[ 0.34865, 0.65135 ]
B
1
243
1.35
ERQA_40
Trajectory Reasoning
B
ABCD
[ 0.41184, 0.32074, 0.13371, 0.13371 ]
A
1
250
1.74
ERQA_41
Action Reasoning
C
ABCD
[ 0.48361, 0.37664, 0.13856, 0.0012 ]
A
1
159
1.26
ERQA_42
Action Reasoning
C
ABCD
[ 0.1611, 0.01167, 0.81814, 0.00909 ]
C
1
162
1.67
ERQA_43
Action Reasoning
A
ABCD
[ 0.84418, 0.08898, 0.06115, 0.00569 ]
A
1
237
2.34
ERQA_44
Spatial Reasoning
C
ABCD
[ 0.11439, 0.2137, 0.01366, 0.65825 ]
D
1
264
1.65
ERQA_45
Pointing
A
ABCD
[ 0.98864, 0.00855, 0.00191, 0.0009 ]
A
1
215
1.21
ERQA_46
State Estimation
A
ABCD
[ 0.96501, 0.00128, 0.03302, 0.00069 ]
A
1
287
1.91
ERQA_47
State Estimation
D
ABCD
[ 0.01638, 0.12103, 0.07341, 0.78919 ]
D
1
275
2.39
ERQA_48
Spatial Reasoning
B
ABCD
[ 0.06594, 0.55207, 0.37943, 0.00256 ]
B
1
274
1.91
ERQA_49
Action Reasoning
A
ABCD
[ 0.26248, 0.3819, 0.23164, 0.12399 ]
B
1
295
2.68
ERQA_50
Trajectory Reasoning
D
ABCD
[ 0.27765, 0.21623, 0.10214, 0.40398 ]
D
1
198
1.78
ERQA_51
State Estimation
B
ABCD
[ 0.45342, 0.18901, 0.00445, 0.35312 ]
A
1
276
2.2
ERQA_52
Pointing
B
ABCD
[ 0.11504, 0.75015, 0.00446, 0.13036 ]
B
1
223
2.06
ERQA_53
State Estimation
B
AB
[ 0.0534, 0.9466 ]
B
1
240
2.08
ERQA_54
State Estimation
A
ABCD
[ 0.53036, 0.10443, 0.08133, 0.28388 ]
A
1
258
2.19
ERQA_55
Action Reasoning
A
ABCD
[ 0.23759, 0.00435, 0.11223, 0.64583 ]
D
1
165
0.75
ERQA_56
Action Reasoning
B
ABCD
[ 0.26379, 0.71706, 0.01488, 0.00426 ]
B
1
185
1.24
ERQA_57
State Estimation
A
ABCD
[ 0.30433, 0.0679, 0.23701, 0.39076 ]
D
1
170
1.11
ERQA_58
Action Reasoning
C
ABCD
[ 0.48273, 0.22803, 0.25839, 0.03086 ]
A
1
152
1.32
ERQA_59
Trajectory Reasoning
C
ABCD
[ 0.0777, 0.65058, 0.23933, 0.03239 ]
B
1
180
1.12
ERQA_60
Spatial Reasoning
B
ABCD
[ 0.17197, 0.09205, 0.05583, 0.68015 ]
D
1
221
1.22
ERQA_61
Spatial Reasoning
A
ABCD
[ 0.38865, 0.0596, 0.4404, 0.11135 ]
C
1
257
1.6
ERQA_62
Action Reasoning
C
ABCD
[ 0.0456, 0.62943, 0.29732, 0.02766 ]
B
1
162
0.77
ERQA_63
Trajectory Reasoning
B
ABCD
[ 0.12372, 0.3811, 0.15886, 0.33632 ]
B
1
177
1.26
ERQA_64
Action Reasoning
B
ABCD
[ 0.14289, 0.82226, 0.03188, 0.00297 ]
B
1
188
1.19
ERQA_65
Action Reasoning
A
ABCD
[ 0.76581, 0.19363, 0.03813, 0.00244 ]
A
1
138
0.76
ERQA_66
Action Reasoning
D
ABCD
[ 0.64132, 0.18374, 0.07659, 0.09835 ]
A
1
200
0.95
ERQA_67
Spatial Reasoning
B
ABCD
[ 0.11877, 0.87759, 0.00085, 0.00279 ]
B
1
259
1.3
ERQA_68
State Estimation
B
AB
[ 0.06009, 0.93991 ]
B
1
240
1.79
ERQA_69
Trajectory Reasoning
B
ABCD
[ 0.29346, 0.54826, 0.08408, 0.0742 ]
B
1
308
1.46
ERQA_70
Action Reasoning
A
ABCD
[ 0.46407, 0.46407, 0.07117, 0.0007 ]
A
1
164
1.03
ERQA_71
Spatial Reasoning
C
ABCD
[ 0.00668, 0.00217, 0.99076, 0.0004 ]
C
1
276
1.93
ERQA_72
State Estimation
B
ABCD
[ 0.06641, 0.12406, 0.80899, 0.00054 ]
C
1
312
2
ERQA_73
Action Reasoning
D
ABCD
[ 0.33856, 0.43471, 0.0856, 0.14113 ]
B
1
333
2.01
ERQA_74
Pointing
C
ABCD
[ 0.90153, 0.074, 0.02403, 0.00044 ]
A
1
396
1.99
ERQA_75
State Estimation
A
AB
[ 0.34865, 0.65135 ]
B
1
266
2.76
ERQA_76
Pointing
A
ABCD
[ 0.18294, 0.04626, 0.5635, 0.2073 ]
C
1
356
2
ERQA_77
Pointing
A
ABCD
[ 0.99057, 0.00405, 0.00459, 0.0008 ]
A
1
326
2.09
ERQA_78
Spatial Reasoning
C
ABCD
[ 0.01391, 0.00956, 0.97523, 0.00129 ]
C
1
276
1.61
ERQA_79
Multi-view Reasoning
C
ABCD
[ 0.00776, 0.54437, 0.42395, 0.02392 ]
B
2
211
1.65
ERQA_80
Multi-view Reasoning
C
ABCD
[ 0.06881, 0.73975, 0.18704, 0.0044 ]
B
2
209
1.04
ERQA_81
Multi-view Reasoning
B
ABCD
[ 0.13793, 0.33087, 0.37492, 0.15629 ]
C
2
219
1.14
ERQA_82
Multi-view Reasoning
C
ABCD
[ 0.41858, 0.47432, 0.07274, 0.03436 ]
B
2
213
1.26
ERQA_83
Multi-view Reasoning
A
ABCD
[ 0.3218, 0.36464, 0.19518, 0.11838 ]
B
2
206
1.38
ERQA_84
Task Reasoning
A
AB
[ 0.7773, 0.2227 ]
A
1
128
1.18
ERQA_85
Task Reasoning
B
AB
[ 0.20181, 0.79819 ]
B
1
129
1.01
ERQA_86
Multi-view Reasoning
B
ABCD
[ 0.17629, 0.12116, 0.32935, 0.3732 ]
D
2
209
1.51
ERQA_87
Multi-view Reasoning
B
ABCD
[ 0.25703, 0.25703, 0.1559, 0.33004 ]
D
2
209
1.73
ERQA_88
Task Reasoning
C
ABCD
[ 0.04151, 0.01189, 0.83376, 0.11284 ]
C
4
508
5.32
ERQA_89
Task Reasoning
D
ABCD
[ 0.05646, 0.04982, 0.60699, 0.28672 ]
C
4
344
2.16
ERQA_90
Task Reasoning
C
ABCD
[ 0.09369, 0.00871, 0.88888, 0.00871 ]
C
4
518
3.29
ERQA_91
Task Reasoning
A
ABCD
[ 0.19311, 0.28097, 0.4088, 0.11712 ]
C
4
342
2.04
ERQA_92
Multi-view Reasoning
A
ABCD
[ 0.48891, 0.14007, 0.14007, 0.23094 ]
A
2
206
1.17
ERQA_93
State Estimation
B
AB
[ 0.09535, 0.90465 ]
B
1
131
1.12
ERQA_94
State Estimation
A
AB
[ 0.10669, 0.89331 ]
B
1
131
0.85
ERQA_95
Task Reasoning
C
ABCD
[ 0.25059, 0.01414, 0.13413, 0.60114 ]
D
4
334
1.8
ERQA_96
Task Reasoning
B
ABCD
[ 0.10323, 0.31796, 0.36029, 0.21853 ]
C
4
361
1.68
ERQA_97
Multi-view Reasoning
B
ABCD
[ 0.24608, 0.07989, 0.35805, 0.31598 ]
C
2
205
1.02
ERQA_98
Task Reasoning
A
ABCD
[ 0.1715, 0.00968, 0.59861, 0.22021 ]
C
4
337
1.81
ERQA_99
State Estimation
B
AB
[ 0.00669, 0.99331 ]
B
1
252
2.19
ERQA_100
Task Reasoning
D
ABCD
[ 0.032, 0.72822, 0.23642, 0.00337 ]
B
4
346
1.79
End of preview. Expand in Data Studio

RoboRACE

Byzantine-robust multi-agent robotics — when some of your robots, cameras or AI agents are wrong on purpose

CPU-only · 2 public benchmarks (ERQA, PlanBench) + 5 RoboRACE tracks · two robot arms, a mobile-robot maze swarm, real VLMs and LLMs · two learned models on one design (RACE-Net-V, RACE-Net-M) · a hold-out evaluated after a recorded freeze · every number regenerated from cached outputs

Leaderboard · Protocol · Models · Plan · Architecture · Videos · Figures

🤗 Dataset · full work · 🤗 Model · RACE-Net-V · 🤗 Model · RACE-Net-M · 🤗 Space · showcase · 🤗 Space · liar playground

SO-101 arm rollouts seen by five camera agents; three cameras lie; majority vote flips, RACE-S stays correct

A MuJoCo SO-101 arm (Menagerie model) runs pick-and-place; ground truth is the final physics state. Five camera agents judge success with Cosmos-Reason2-2B on a CPU. Then 3 of 5 cameras invert their reports: majority vote flips, RACE-S learns negative weights for the liars without labels and stays correct. The GIF is a 12-second highlight; the full 43-second film (3 episodes) is the MP4 (1280×720, 30 fps).

This is the Hugging Face home of RoboRACE. It holds the complete, detailed work: code, the cached outputs of every agent (VLMs, LLMs, simulated robots), per-cell benchmark results, leaderboards, figures, videos and the 1,100 SO-101 camera renders for each of two robot arms. Code is mirrored on GitHub: github.com/Hisernberg/robotics. Showcase page: Space · Nabidnur/RoboRACE · interactive: Space · liar playground · model: Nabidnur/RoboRACE-Net.

Videos


SO-101 camera swarm: three physics rollouts, five Cosmos-Reason2 camera agents, honest swarm vs 3-of-5 liars.

Byzantine rendezvous: 12 robots, 4 colluding liars — DeGroot vs W-MSR vs RACE-C + W-MSR.

PlanBench LLM-Modulo: a real cached LLM plan is rejected by the exact simulator and repaired.

Maze swarm (Track D): three of six robots invert their map reports — majority map vs RACE map.

Franka Panda camera swarm: the cross-embodiment replication.

Track A0 (first iteration): procedural scenes judged by the same camera swarm.

What is in this repository

path content
data/so101/{hist,eval}/<seed>/<camera>.png 220 SO-101 episodes × 5 cameras (448×448), with per-split metadata.jsonl
viewer/<config>/*.parquet Parquet copies behind the dataset viewer; so101_views embeds every image with its task, physics label, failure mode and Cosmos score
data/so101/episodes.jsonl per-episode metadata: task, family (put / stack), scripted mode, physics ground truth, final object pose
results/so101/vlm_scores.jsonl Cosmos-Reason2-2B P(success) for every (episode, camera) — config so101_vlm_scores
data/panda/..., results/panda/vlm_scores.jsonl the same for the Franka Panda replication (220 episodes × 5 cameras) — configs panda_views, panda_vlm_scores
data/*_holdout/..., results/*_holdout/vlm_scores.jsonl, results/holdout/FREEZE.json the hold-out: 170 new episodes per arm, evaluated only after the recorded freeze commit — configs so101_holdout_views, panda_holdout_views and the matching *_vlm_scores
models/racenet, models/racenet_m weights of both models (RACE-Net-V, RACE-Net-M) and every candidate checkpoint
results/trackD/rows.json Track D maze swarm: SPL and success of every fusion rule in every (maze, attack, liar-count) cell — config trackD_maze_results
results/maze_llm/<agent>.jsonl LLM agents on text mazes: every attempt, validator feedback, repair count — config maze_llm_agents
models/racenet/ RACE-Net weights (safetensors), config and training log; also at Nabidnur/RoboRACE-Net
results/kaggle/ independent replication run on Kaggle CPU (log + comparison)
results/erqa/cosmos_r2_2b*.jsonl ERQA: full option distributions for all 400 questions at ≤448² and ≤768² px — config erqa_cosmos_reason2_2b
results/erqa/<agent>.jsonl ERQA answers + raw replies of hosted VLM agents (Gemini, Qwen, Gemma, Gemini Robotics-ER) — config erqa_hosted_agents
results/planbench/<agent>.jsonl PlanBench Blocksworld: every attempt, parsed plan, validator verdict, repair count — config planbench_agents
results/trackC/answers.jsonl Track C: zero-shot / engineered / saboteur answers of 4 LLMs — config trackC_llm_planners
results/*/rows.json, results/leaderboard.json, results/LEADERBOARD.md per-cell results of every method under every attack and receiver; bootstrap-ranked leaderboards
media/ figures, architecture diagrams (Raschka style + PlotNeuralNet), videos (MP4 + GIF)
src/, scripts/, tests/, docs/ the full code base, protocol (BENCHMARK) and research plan (PLAN)
from datasets import load_dataset
views  = load_dataset("Nabidnur/RoboRACE-Bench", "so101_views", split="evaluation")      # images + labels
scores = load_dataset("Nabidnur/RoboRACE-Bench", "so101_vlm_scores", split="train")      # Cosmos-Reason2 P(success) per camera
erqa   = load_dataset("Nabidnur/RoboRACE-Bench", "erqa_cosmos_reason2_2b", split="px448")
plans  = load_dataset("Nabidnur/RoboRACE-Bench", "planbench_agents", split="train")

Re-run every number on a CPU from this repository:

huggingface-cli download Nabidnur/RoboRACE-Bench --repo-type dataset --local-dir RoboRACE-Bench && cd RoboRACE-Bench
pip install -r requirements.txt && python scripts/run_benchmark.py --reuse-tracks && python scripts/make_figures.py

Headline results

benchmark what is measured strongest baseline ours
ERQA (Gemini Robotics team, 400 Q) reproduce Cosmos-Reason2-2B on CPU NVIDIA reports 37.75 33.8 (95% CI 29.3–38.5) ✓ inside
ERQA multi-agent 4 VLM agents, 283 shared Q best single agent 54.1 best swarm 54.8 · robot's own model 37.1 → 43.8 with CGA
PlanBench Blocksworld plan generation, 92 instances official one-shot prompt LLM-Modulo + swarm cascade: see table
Track A SO-101 camera swarm success verification under 7 attacks receiver alone 71.3 · majority 59.8 83.4 race_net (new, learned) (rank 1)
Track A-Panda cross-embodiment same protocol on a Franka Panda, methods frozen receiver alone 74.5 · majority 62.2 87.0 race_s_online (new)
RACE-Net-V (our model, 0.2 M params) learned fusion, zero-shot on real camera swarms RACE-S online 82.7 / 87.0 83.4 SO-101 (rank 1) / 84.2 Panda · RACE-Pool 82.0 / 85.9
Hold-out (new episodes, both arms, evaluated after the freeze) same protocol, nothing tuned on it receiver alone 72.7 / 77.1 · majority 62.3 / 64.2 RACE-S online 82.6 / 85.4 · RACE-Pool 81.2 / 86.7 · RACE-Net-V 79.0 / 84.3
Track B 12-robot rendezvous mission success, up to 5 Byzantine robots W-MSR 82.1 94.3 RACE-C + W-MSR (rank 1)
Track D maze swarm · RACE-Net-M (our model, 45 K params) SPL under 6 attacks, 10 fusion rules W-MSR trimming 64.1 · beta-reputation 63.8 · EigenTrust 63.0 70.2 RACE-Net-M (rank 1; oracle 71.3) · hand-written RACE map 66.2
Track C LLM planners exact-plan accuracy zero-shot mean 88.1 engineered mean 98.2 · flash-lite 69.0 → 92.9

Videos (GIF previews play inline below; full-quality 1280×720 MP4s): SO-101 camera swarm · Byzantine rendezvous · PlanBench LLM-Modulo replay · maze swarm · maze, wall-inventing liars · Franka Panda camera swarm

The idea in one paragraph

A robot team fuses evidence from many agents. Some of them are broken, biased, colluding or adversarial. Majority vote and classical crowdsourcing (Dawid–Skene, GLAD, MACE) fail once liars are the majority, because the latent-truth model becomes symmetric. RACE (from the Liars Are Information program) breaks the symmetry with an anchor: each receiver knows it is honest. Peers then get signed channel weights: positive means trust, negative means invert, near zero means discard. A consistent liar carries information. This repo adds RACE-S (score level), online variants (against sleepers), confidence-gated anchoring (CGA) (a measured compromise between robustness and clean-data gains), RACE-C + W-MSR (continuous robot consensus), an engineered / LLM-Modulo planning layer, and two learned versions of the idea: RACE-Net-V for camera swarms and RACE-Net-M for map fusion, plus RACE-Pool, an AIP-style pool of anchored experts.

Architecture



Same verifier as a PlotNeuralNet tensor diagram (one 448×448 view → 196 image tokens → P(yes)). Exact numbers come from the checkpoint: 2.44 B parameters (LLM decoder 1,409 M, embeddings 311 M, untied head 311 M, ViT 302 M, merger + DeepStack 101 M). Vector version: PDF (LaTeX source alongside). Diagrams are drawn by scripts/make_architecture.py in the style of Sebastian Raschka's LLM architecture figures.

Our two models: one design

RACE-Net-V · pick-and-place RACE-Net-M · maze
question did the arm succeed? (camera swarm) which cells are walls? (robot swarm)
receiver's anchor its own score for every episode its own exact sensing of some cells
structure axial set transformer over agents × episodes anchored channel encoder → peer transformer → signed read-out, 3 refinement rounds
shared design anchor on the receiver · estimate each peer's channel in context · invert consistent liars · sets, not sequences · synthetic training only
size · training 213,889 parameters · synthetic swarms 44,837 parameters · simulated mazes with random liars

Both come from RACE and AIP in the Liars Are Information program: RACE supplies the anchored, signed channel estimation; AIP supplies the pooling of experts (RACE-Pool). The full description is in docs/MODELS.md.


Part I — public benchmarks

ERQA — embodied reasoning

Reproduction. Cosmos-Reason2-2B on 4 CPU cores (bf16, ≤448² px, option letter = argmax of next-token logits): 33.8% (95% CI 29.3–38.5, n = 400, 1.3 s per question). NVIDIA reports 37.75%, which is inside our CI. Multi-view questions are the weakest category (16.2%). Resolution ablation (≤768² px): 35.5% overall. Only 31.2% of questions contain an image larger than 448², and 19 of 400 answers change. Multi-view rises from 16.2% to 24.3% (4 gained vs 1 lost of 37; exact McNemar p = 0.38). The direction suggests resolution matters for multi-view matching, but the effect is not significant at n = 37, and most of the weakness remains a capability limit of the 2B model.

Multi-agent swarm (cosmos_r2_2b, gemini-3.1-flash-lite, gemini-3.5-flash-lite, qwen3.8-27b@cerebras; 283 questions answered by every agent, seeded random order):

system accuracy 95% CI category-reweighted
⊕ Dawid-Skene (crowd-kit) 54.8 48.9–60.5 54.5
Qwen3.8-27B @Cerebras 54.1 48.2–59.8 53.7
⊕ RACE · receiver = Gemini-3.1-flash-lite 53.0 47.2–58.7 52.9
⊕ RACE · receiver = Gemini-3.5-flash-lite 53.0 47.2–58.7 52.9
⊕ RACE · receiver = Qwen3.8-27B @Cerebras 53.0 47.2–58.7 52.9
⊕ RACE sign-only anchor · receiver = Gemini-3.1-flash-lite 53.0 47.2–58.7 52.9
⊕ RACE sign-only anchor · receiver = Gemini-3.5-flash-lite 53.0 47.2–58.7 52.9
⊕ RACE sign-only anchor · receiver = Qwen3.8-27B @Cerebras 53.0 47.2–58.7 52.9
⊕ RACE sign-only anchor · receiver = Cosmos-Reason2-2B (CPU, ours) 52.3 46.5–58.0 52.1
Gemini-3.5-flash-lite 51.9 46.1–57.7 51.4
⊕ plurality 51.2 45.4–57.0 50.8
Gemini-3.1-flash-lite 50.2 44.4–56.0 50.0
⊕ RACE CGA · receiver = Cosmos-Reason2-2B (CPU, ours) 43.8 38.2–49.6 43.3
Cosmos-Reason2-2B (CPU, ours) 37.1 31.7–42.9 36.5
⊕ RACE · receiver = Cosmos-Reason2-2B (CPU, ours) 37.1 31.7–42.9 36.5

Gemini Robotics-ER 2, the SOTA reference, could only be queried on 46 shared questions before its free-tier daily quota ran out. On that subset it scores 82.6%.

Cosmos-Reason2-2B as a success verifier (calibration study on held-out scenes)


The model's P(yes) is biased toward "yes": the naive 0.5 threshold accepts almost everything. A threshold chosen on a calibration split lifts held-out accuracy from 56% to 83% (AUROC 0.925); scripts/eval_verifier.py.

Robustness vs usefulness. With the robot's own CPU model as the receiver, the strong RACE anchor is the only rule whose worst attacked cell never drops below the robot alone (37.1 vs 37.1), but it gains nothing on clean data. The sign-only anchor and Dawid–Skene gain a lot on clean data (52.3 / 53.0) and collapse under coherent liars (worst cell 15.2). CGA sits in between: clean 43.8 and worst cell 31.1. On an earlier 136-question subset its worst cell matched the receiver. On the full 220-question set and on Track A (39.1 vs 55.5) it does not, so we report CGA as a compromise point, not a dominating method.

PlanBench Blocksworld — the validator is the planner


A real cached LLM plan: the simulator rejects step 11 ("the red block is not clear"); the error message is fed back, and the repaired plan reaches the goal. MP4

Our exact Blocksworld simulator accepts all 500 official ground-truth plans (tests/test_blocksworld.py), so it can replace VAL on this domain. Results on 92 instances that every listed agent answered:

agent / strategy one-shot (official prompt) LLM-Modulo (≤3 repairs) gain LLM calls / task
gemini-3.1-flash-lite 69.6 95.7 +26.1 1.47
gpt-oss-120b@groq 91.3 100.0 +8.7 1.10
qwen3.8-27b@cerebras 97.8 100.0 +2.2 1.02
qwen3.8-27b@groq 43.5 72.8 +29.3 2.26
swarm cascade-Modulo (cheap → expensive) – 100.0 1.02
swarm verify-select (one-shot, 4 agents) – 100.0 4.00
swarm plurality (one-shot, 4 agents) – 90.2 4.00

The same Qwen3.8-27B weights behave very differently on two providers (Groq vs Cerebras). That is a reproducibility hazard worth reporting in its own right.


Part II — RoboRACE-Bench

Track A — SO-101 camera swarm

220 physics rollouts (110 unlabelled history, 110 evaluation, balanced). Failures are real physics: missed grasps, drops in transit, near-miss placements and wrong objects. Each of 5 cameras is an agent (Cosmos-Reason2-2B). Every camera takes a turn as the receiver.

rank (90% CI) method mean clean liars < 50% liars ≥ 50% worst cell
1 (1–1) race_net (new, learned) 83.4 88.2 85.1 80.0 53.6
2 (2–2) race_s_online (new) 82.7 87.3 84.2 79.8 54.5
3 (3–3) race_pool (new) 82.0 86.2 83.8 78.7 54.5
4 (4–4) race_online (new) 77.7 83.6 79.7 73.9 49.1
5 (5–6) race CGA (new) 77.1 83.6 79.7 72.1 39.1
6 (5–7) race_s (new) 76.3 85.1 78.6 71.9 49.1
7 (6–8) race_online sign-only anchor (ablation) 76.0 83.6 79.6 69.1 16.4
8 (7–8) race 75.0 83.3 78.0 69.3 44.5
ref REF stack_lr (labelled) 82.6 92.7 84.9 78.1 48.2

More Track A figures: per-camera quality, method leaderboard, accuracy by attack


RACE-S signed weights, learned without labels: inverted cameras get negative weight (their reports are reused), noisy or stuck cameras get ≈0.

Track A-Panda — does it replicate on a different robot?

Every method and hyper-parameter was frozen (and pushed) before this data existed. The same tasks, cameras, failure modes and physics-based labels were then generated with a Franka Panda (7-DOF, MuJoCo Menagerie): 220 new episodes, 1,100 new Cosmos-Reason2 views.


Franka Panda rollouts with the camera swarm's verdicts. MP4

rank (90% CI) method mean clean liars < 50% liars ≥ 50% worst cell
1 (1–1) race_s_online (new) 87.0 91.8 88.7 83.6 53.6
2 (2–2) race_pool (new) 85.9 90.5 87.7 82.4 53.6
3 (3–3) race_net (new, learned) 84.2 86.0 85.6 81.5 54.5
4 (4–4) race_online (new) 83.2 90.0 85.9 78.0 49.1
5 (5–6) race CGA (new) 82.7 90.0 85.9 76.6 34.5
6 (6–8) race_online sign-only anchor (ablation) 81.8 90.0 85.9 74.2 5.5
7 (5–7) race 81.7 94.2 86.8 71.9 5.5
8 (7–8) race_s (new) 80.4 91.3 82.9 75.3 50.0
ref REF stack_lr (labelled) 84.9 96.4 87.0 80.7 50.0

The best method on the Panda is race_s_online (new) (87.0; liar-majority cells 83.6 vs majority vote 48.8). The left panel plots every method's mean accuracy on the SO-101 against the Panda.

Full Track A-Panda bar chart (all methods)

RACE-Net-V — the learned verification model

RACE and RACE-S run a hand-specified EM on every window. RACE-Net-V is a 214,145-parameter axial set transformer that has learned the same receiver-anchored inference: it reads a whole window of unlabelled swarm reports, knows only which column is the receiver, and outputs P(success) for every episode. It is trained only on synthetic swarms (no benchmark data, labels or agent outputs) and then applied unchanged to the real Cosmos-Reason2 camera swarms. The released checkpoint is the EM-refinement variant: it also receives the RACE-S and RACE estimates of the window and learns to refine them. RACE-Pool is the AIP-style pool of RACE-Net-V, RACE-S and RACE (design).

mean accuracy over all attack cells A0 procedural (development) SO-101 (test) Franka Panda (test)
majority vote 68.5 59.8 62.2
Dawid–Skene (crowd-kit) 69.4 60.1 65.0
RACE online 90.3 77.7 83.2
RACE-S online 91.2 82.7 87.0
RACE-Net-V (learned, zero-shot) 91.5 83.4 84.2
RACE-Pool (RACE-Net-V + RACE-S + RACE) 92.4 82.0 85.9
labelled stacker (reference) 84.8 82.6 84.9

Liar-majority cells: RACE-Net-V 80.0 on SO-101 and 81.5 on the Panda (RACE-S online: 79.8 / 83.6). Weights, config and a standalone inference file are in models/racenet and on the Hub: 🤗 Nabidnur/RoboRACE-Net.

Checkpoints and selection. Rule: highest mean accuracy of RACE-Net-V over three development sets (A0 evaluation window, SO-101 history split, Panda history split; equal weight); ties within 0.1 point go to the higher synthetic accuracy. The history splits are the benchmark's unlabelled calibration data; no label-free method ever used their labels, so they serve as development data for the two arms, and the evaluation splits stay test sets. Test columns were computed after the choice and are shown for transparency. On the same development sets RACE-S online scores 84.9 and RACE online 83.8.

checkpoint generator · type steps params synthetic (v3) dev: RACE-Net-V (selects) dev: RACE-Pool test SO-101 / Panda: RACE-Net-V test: RACE-Pool
v3 refine · local · 6k (released) v3 · EM-refinement 6,000 214,145 97.8 84.0 85.6 83.4 / 84.2 82.0 / 85.9
v3 large · Kaggle · 9k v3 · plain 9,000 589,729 97.9 83.8 85.6 83.6 / 84.1 82.2 / 85.9
v3 · Kaggle · 15k · seed 1 v3 · plain 15,000 213,889 97.9 83.7 85.5 83.6 / 83.6 82.0 / 85.9
v2 · local · 7k v2 · plain 7,000 213,889 96.7 83.4 85.6 82.6 / 83.5 81.9 / 86.1
v3 · Kaggle · 15k · seed 0 v3 · plain 15,000 213,889 97.9 83.3 85.6 83.8 / 84.0 81.9 / 86.1
v1 · local · 6k v1 · plain 6,000 213,889 97.6 82.2 85.0 81.6 / 81.8 81.7 / 85.5
v1 · Kaggle · 15k v1 · plain 15,000 213,889 97.8 82.0 85.0 80.9 / 82.3 81.4 / 85.4

Checkpoints marked Kaggle were trained in Kaggle CPU notebooks (4 vCPU; logs in results/kaggle/). All checkpoints are in models/racenet/candidates/.

Scaling study (scripts/racenet_analysis.py; an independent synthetic generator, not the training distribution; 20 seeds per point):

  • Liar majority. With 3 of 5 agents lying: RACE-Net-V 80.1, RACE-S online 77.6, RACE online 76.8, majority 45.5. With 15 of 16 lying: 86.7 / 83.4 / 78.7 / 21.9.
  • Short windows. With only 8 unlabelled episodes: RACE-Net-V 71.7, RACE-S online 72.8, receiver alone 70.0; no label-free method beats the receiver before about 32 episodes.
  • Large swarms. At 24 agents (larger than any training swarm): RACE-Net-V 93.8, RACE online 93.4, RACE-S online 93.2.
  • Weak receiver (open weakness). If the receiver is only 55% accurate and nobody lies, RACE-Net-V reaches 65.8 and RACE-S online 54.4, while majority reaches 81.8 and discrete RACE 82.4. Score-level anchoring trusts a weak receiver too much; from a 70% receiver upwards the gap is gone.
  • Against the first release. Weak receivers: 65.8 at 55% and 87.3 at 70% receiver accuracy (first release 57.1 and 77.4). 24-agent swarms: 93.8 (first release 89.1).
  • RACE-Pool on the same sweeps: 79.2 with 3 of 5 lying, 94.9 at 24 agents, 68.2 with a 55% receiver.

Hold-out — a test nothing was tuned on

Both earlier test tracks were looked at while RACE-Net-V was being developed. For a clean final number, 1,700 new camera views were generated with new seeds for both arms (60 history + 110 evaluation episodes each). The views were scored by the frozen Cosmos-Reason2 pipeline, and no fusion method was run on them until commit 5b2bc8e had frozen every model, rule and threshold (results/holdout/FREEZE.json; run_benchmark.py refuses to evaluate the hold-out without that record).

SO-101 hold-out

rank (90% CI) method mean clean liars < 50% liars ≥ 50% worst cell
1 (1–1) race_s_online (new) 82.6 86.7 84.1 79.7 53.6
2 (2–2) race_pool (new) 81.2 84.9 82.9 78.0 52.7
3 (3–3) race_online (new) 79.9 86.5 82.1 75.6 52.7
4 (4–5) race CGA (new) 79.4 86.5 82.1 74.3 37.3
5 (4–6) race_net (new, learned) 79.0 77.1 80.0 77.2 55.5
6 (5–6) race_online sign-only anchor (ablation) 78.4 86.5 82.2 71.3 11.8
7 (7–7) race 74.3 80.0 76.8 69.7 33.6
ref REF stack_lr (labelled) 82.6 93.6 85.3 77.5 45.5

Franka Panda hold-out

rank (90% CI) method mean clean liars < 50% liars ≥ 50% worst cell
1 (1–1) race_pool (new) 86.7 90.9 88.7 83.1 56.4
2 (2–3) race_online (new) 85.9 92.7 89.0 80.1 51.8
3 (2–4) race_s_online (new) 85.4 89.1 87.0 82.5 58.2
4 (3–5) race CGA (new) 84.8 92.7 88.9 77.1 35.5
5 (4–6) race_net (new, learned) 84.3 87.5 85.7 81.6 54.5
6 (5–7) race_online sign-only anchor (ablation) 83.4 92.7 88.9 73.0 6.4
7 (6–7) race 82.1 89.5 85.3 76.1 48.2
ref REF stack_lr (labelled) 82.6 93.6 84.7 78.5 50.0
hold-out comparison difference 95% CI (cells) better / worse
SO-101 race_pool − race_s_online -1.4 -1.8 … -1.0 110 / 199
SO-101 race_net − race_s_online -3.6 -4.2 … -3.0 65 / 254
SO-101 race_net − race_online -0.9 -1.6 … -0.2 148 / 191
Panda race_pool − race_s_online +1.3 +1.0 … +1.5 270 / 49
Panda race_net − race_s_online -1.2 -1.5 … -0.8 80 / 225
Panda race_net − race_online -1.6 -2.3 … -0.9 81 / 252

Reading. On data nothing was tuned on, the receiver-anchored family keeps its margin over every literature baseline (majority 62.3 / 64.2, Dawid–Skene (crowd-kit) 62.3 / 68.8, receiver alone 72.7 / 77.1). Among our own methods the EM-based ones are ahead: RACE-S online is rank 1 on SO-101 and RACE-Pool is rank 1 on the Panda. The learned RACE-Net-V is rank 5 and 5 (79.0 / 84.3); its first place on the SO-101 test track (83.4) does not replicate here. For camera swarms the recommendation is therefore RACE-S online or RACE-Pool. RACE-Net-V is within 1 to 4 points of them, which is the honest size of the gap between learning the inference from simulated swarms and fitting it on the window at hand.

Track B — rendezvous with Byzantine robots


MP4 · same robots, same lies, three consensus rules; red dashed = link isolated online by RACE-C.

rank (90% CI) method mean clean liars < 50% liars ≥ 50% worst cell
1 (1–1) race_c+wmsr 94.3 100.0 94.1 – 0.0
2 (2–3) geomedian 87.1 100.0 86.7 – 0.0
3 (3–5) median 84.3 100.0 83.8 – 0.0
4 (3–5) trimmed 83.7 100.0 83.2 – 0.0
5 (3–6) wmsr 82.1 100.0 81.5 – 12.5
6 (2–6) race_c 72.9 82.5 72.6 – 0.0
7 (7–7) mean 3.2 100.0 0.0 – 0.0

More Track B figures: method leaderboard, mission success by attack

Track C — LLM planners: same models, better plumbing

Track C swarm leaderboard (real LLM saboteurs, every agent as receiver)

After engineering, every receiver is ~98% accurate on its own, so fusion can only cost accuracy; RACE costs the least. Full table: leaderboard.
Track A0 — the first iteration (procedural tabletop scenes, kept for continuity)


Procedural MuJoCo scenes judged by the same five-camera Cosmos swarm; superseded by the SO-101 physics rollouts above. MP4 · results in the leaderboard (Track A0).

Track D — maze exploration with lying robots

Six mobile robots must each reach a goal in an unknown maze. Each senses its 8 neighbouring cells, broadcasts what it sensed, and re-plans every step on its fused belief map. Up to four robots corrupt their broadcasts (false walls, false openings, full inversion, random, a colluding bloc that walls off the goal, sleepers). Score = SPL (success weighted by path length) of the honest robots.


Three of six robots invert their reports. Majority map fusion believes the false walls (red); RACE-Net-M verifies each peer against cells the robot sensed itself and inverts the liars. This is the maze with the largest gap between the two rules; averages are in the table. MP4

RACE-Net-M is the learned map-fusion model (design): 44,837 parameters, trained on simulated maze swarms with random two-coin liars. The benchmark's attack names never appear in its training, and the colluding ring attack is outside that family. It is compared with six rules from the literature and with our hand-written race_map on 20 fresh mazes × 25 conditions.

rank (90% CI) method mean clean liars < 50% liars ≥ 50% worst cell
1 (1–1) race_net_m + reach-repair 70.2 76.8 73.1 66.8 0.0
2 (2–2) race_net_m 69.8 76.8 72.6 66.4 0.0
3 (3–3) race_map 66.2 76.8 69.7 61.8 0.0
4 (4–5) wmsr_trim 64.1 76.8 65.6 61.5 13.9
5 (4–6) reputation 63.8 76.8 67.9 58.5 0.0
6 (5–7) eigentrust 63.0 75.0 66.8 58.2 0.0
7 (6–8) dawid_skene 62.0 76.3 67.4 55.5 0.0
8 (7–8) solo 61.6 61.5 62.0 61.2 13.9
9 (9–9) trust_all 56.7 76.8 59.9 51.7 0.0
10 (10–10) majority 55.7 76.8 61.5 48.1 0.0
ref REF oracle 71.3 76.8 74.5 67.5 0.0
  • Rank 1. RACE-Net-M scores 69.8 (70.2 with reachability repair), against 66.2 for the hand-written race_map and 64.1 for the best literature baseline (wmsr_trim). The oracle that knows who lies scores 71.3.
  • Goal reached in time: RACE-Net-M + repair 97.8%, RACE-Net-M 97.4%, race_map 94.2%, W-MSR trimming 96.5%, beta-reputation 91.9%, majority 82.1% (oracle 98.2%).
  • Wall-inventing liars, the weak spot of race_map (59.5), are handled: RACE-Net-M 71.7.
  • Still open: the colluding ring (66.2 with repair, oracle 71.0). The liars are honest everywhere else, so their channel looks reliable until a robot stands next to the goal.


Three of six robots invent walls. Beta-reputation believes dozens of them; RACE-Net-M learns that these peers' wall reports are worthless while their "free" reports are true, and keeps only the latter. MP4

Belief quality on held-out mazes (accuracy on cells a peer reported and the receiver has not sensed; 6,111 snapshots):

model all 3 of 5 peers lie 5 of 5 peers lie
race_map (hand-written Bayesian rule) 90.1 82.7 72.9
rounds = 1 (no refinement) 91.8 85.7 76.1
rounds = 2 92.2 86.4 77.4
rounds = 3 (released) 92.3 86.7 77.6
rounds = 3, second seed 92.3 86.7 77.6

Other swarm and map sizes. The model was trained on 6 robots in 12×12-cell mazes. Unchanged, with half of the robots lying (10 new mazes × 5 attacks per row; computed in a Kaggle CPU notebook):

setting liars beta-reputation W-MSR trimming race_map RACE-Net-M + repair oracle
4 robots · 8×8 2 74.4 72.0 73.3 73.6 76.1
6 robots · 12×12 (training size) 3 61.1 54.0 63.6 67.7 66.9
10 robots · 12×12 5 70.7 60.5 70.6 76.7 77.5
8 robots · 16×16 4 57.5 59.4 62.5 69.5 67.7

In small mazes (8×8) every rule is within a few points of the others: there is little to gain from peers. The gap grows with the map and the swarm.

Reachability repair (planner ablation, same 500 cells). When the fused map says the goal cannot be reached, the standard planner drops every peer; the repair un-believes only the claimed walls that enclose the goal. It helps every rule against the colluding ring, but it hurts rules whose map is already polluted with false walls, so it only pays off on top of an accurate fusion model:

fusion rule standard fallback + reach-repair collude: standard → repair false_walls: standard → repair
majority 55.7 49.2 63.2 → 66.2 57.6 → 45.5
eigentrust 63.0 61.0 62.6 → 65.0 53.8 → 42.2
reputation 63.8 61.8 62.7 → 66.2 57.0 → 44.8
race_map 66.2 65.6 63.2 → 66.2 59.5 → 54.3
race_net_m 69.8 70.2 63.2 → 66.2 71.7 → 71.2
More Track D figures

LLM agents in text mazes

The same mazes as ASCII text: the agent answers with a move string and an exact simulator returns the first illegal move (LLM-Modulo, ≤3 repairs). All 40 shortest paths validate (tests/test_maze.py). Free-tier quotas cut some agents short, so n differs per agent: compare one-shot with Modulo within a row, not rows with each other.

agent n one-shot Modulo 4×4 6×6 calls
gpt-oss-120b@groq 24 100.0 100.0 100.0 (n=17) 100.0 (n=7) 1.00
qwen3.8-27b@groq 16 93.8 100.0 100.0 (n=13) 100.0 (n=3) 1.06
qwen3.8-27b@cerebras 40 72.5 87.5 100.0 (n=20) 75.0 (n=20) 1.65
gemini-3.1-flash-lite 26 11.5 38.5 62.5 (n=16) 0.0 (n=10) 3.38

Part III — how this compares with published numbers

Grey bars are copied from the cited papers' own tables (ERQA: Gemini Robotics report, Feb 2025, and the NVIDIA Cosmos-Reason2 model card; PlanBench: Valmeekam et al. 2024, 600 instances). Teal bars are measured in this repo. They are context, not same-condition comparisons: the models are newer, hosted agents were run on quota-limited subsets with a brief-reasoning prompt, and our PlanBench numbers use a seeded 100-instance subset. The full tables with sources and confidence intervals are in the leaderboard.


Validation — how we know the numbers are right

claim evidence
ERQA pipeline is faithful reported 37.75% lies inside our 95% CI for Cosmos-Reason2-2B
Blocksworld validator ≡ VAL here accepts 500 / 500 official ground-truth plans; rejects ≥95% of swapped or truncated plans
W-MSR implemented correctly honest states never leave the honest hull (W-MSR safety theorem), 5 attacks × F = 1..3
Dawid–Skene implemented correctly ≥90% decision agreement with the crowd-kit reference implementation on identical data
RACE-S calibration is rank-invariant a cubic distortion of one agent changes ≤2% of decisions
SO-101 labels are physical labels read from the simulator after settling; replay of a cached seed must reproduce its label
no test-set tuning RACE-S hyper-parameters fixed on synthetic data; CGA / sign-only reported as ablations on every benchmark; Track D tuned on separate development mazes; both RACE-Net models trained on simulated swarms only and selected on development data
findings replicate on a new robot all methods frozen before the Franka Panda data was generated (Track A-Panda)
RACE-Net-V and RACE-Net-M are set functions outputs unchanged under any permutation of peers or items (tests/test_racenet.py, tests/test_racenet_m.py)
maze checker is exact all 40 BFS-shortest paths validate with their optimal length (tests/test_maze.py)
hold-out was not peeked at results/holdout/FREEZE.json records the commit that froze every model and rule; run_benchmark.py skips the hold-out without it
RACE-Net-M uses liars instead of discarding them a full inverter alone recovers the map, a coin-flipper adds no evidence (tests/test_racenet_m.py)
literature baselines are faithful EigenTrust drops the inverter, trimming removes F votes per cell, Dawid–Skene is right up to a global flip (tests/test_racenet_m.py)
differences are not noise paired bootstrap intervals (over mazes for Track D) and exact sign tests in the leaderboard
maze data hygiene five disjoint sets of maze seeds: training, validation, development, benchmark, scaling study (protocol)
independent replication on Kaggle CPU a Kaggle notebook (4 vCPU, Intel(R) Xeon(R) CPU @ 2.20GHz) re-ran the tests (60 passed, 4 skipped) and recomputed every track, the hold-out included, from the public Hugging Face copy (revision f4fdc380) in 215 min: 1,864 leaderboard values compared, 1,862 identical, 2 differ by at most 0.00007 (one third-party baseline (crowd-kit GLAD, an iterative optimiser) on the SO-101 hold-out)

pytest runs 64 tests. See docs/BENCHMARK.md for the full protocol and threats to validity.

Reproduce (CPU)

bash scripts/fetch_assets.sh            # SO-101 (MuJoCo Menagerie), PlotNeuralNet, ERQA, PlanBench
python -m venv .venv && .venv/bin/pip install --index-url https://download.pytorch.org/whl/cpu torch torchvision
.venv/bin/pip install -r requirements.txt
MUJOCO_GL=egl .venv/bin/python -m pytest -q
MUJOCO_GL=egl .venv/bin/python scripts/run_benchmark.py && .venv/bin/python scripts/make_figures.py && .venv/bin/python scripts/make_readme.py

Videos (need the SO-101 data and ffmpeg):

MUJOCO_GL=egl .venv/bin/python scripts/make_videos.py && .venv/bin/python scripts/make_gifs.py

RACE-Net (training about 40 min on 4 cores, then dev-only selection and the scaling study):

.venv/bin/python scripts/train_racenet.py --steps 6000 --gen v1 --out models/racenet/candidates/mine
.venv/bin/python scripts/select_racenet.py "mine=models/racenet/candidates/mine" "v1 local=models/racenet/candidates/v1_local" && .venv/bin/python scripts/racenet_analysis.py

Regenerating agent outputs needs HF_TOKEN (access to the gated nvidia/Cosmos-Reason2-2B) and LLM keys as environment variables (.env.example). The scripts are erqa_cosmos.py, erqa_api_agents.py, planbench_agents.py, so101_generate.py and so101_score_views.py.

Repository map

src/robotics/swarm/       race.py (RACE v3.1) · fusion.py (ACL, rank-Gauss, AIP, DS, RACE, RACE-S, CGA) · racenet.py (RACE-Net) · crowd.py · attacks.py
src/robotics/benchmarks/  erqa.py · blocksworld.py (exact simulator + validator) · maze_text.py
src/robotics/bench/       trackA/B/C/D · erqa_swarm · planbench_eval · leaderboard (bootstrap ranks)
src/robotics/sim/         so101_env.py · panda_env.py (IK pick-and-place, physics ground truth) · tabletop.py
models/racenet/           RACE-Net weights (safetensors), config, training log, selection.json, candidates/ (3 checkpoints)
src/robotics/vlm/         cosmos_reason.py (logit P(yes) verifier)
scripts/                  run_benchmark · train_racenet · select_racenet · racenet_analysis · make_figures · make_videos · make_gifs · make_architecture · make_plotnn · make_readme ·
                          publish_hf + make_space + make_playground (Hugging Face dataset, model, Spaces) · agents
results/                  LEADERBOARD.md · leaderboard.json · cached agent outputs
kaggle/                   the two Kaggle CPU notebooks (RACE-Net training, independent replication)
media/                    figures · videos (mp4 + gif) · architecture (Raschka-style + PlotNeuralNet)

Limitations

  • Track A renders are simulated. The SO-101 and Panda meshes are real, but lighting and textures are synthetic, and all cameras share one VLM.
  • Track D is a grid world with exact local sensing; the 3-D view in the video is a rendering of the same run, not a physics simulation.
  • RACE-Net-V is trained on a hand-written simulator of swarms. On the hold-out it is 1 to 4 points behind our EM methods (RACE-S online, RACE-Pool); its first place on the SO-101 test track did not replicate. A weak receiver (below about 60% accuracy) is still an open weakness of every score-level method here.
  • RACE-Net-M is evaluated in one simulator (grid mazes, exact local sensing). A bloc that lies only around the goal still costs about 5 SPL points against the oracle.
  • Online variants fit on the current unlabelled evaluation window; a deployed robot would use a sliding window.
  • ERQA swarm numbers cover the questions that every hosted agent answered within free-tier quotas. Groq Qwen and Gemma-4 were throttled to near-zero coverage and are excluded.
  • PlanBench uses a seeded 100-instance subset. Track C saturates after engineering.
  • CGA was proposed after inspecting ERQA. It is reported on every benchmark with fixed settings, but it deserves confirmation on a fresh benchmark.

Provenance & citation

RACE / Liars Are Information (public demo Space; the dataset Nabidnur/liars-are-information is private) · AIP-AD (Nabidnur/AIP-AD) · ERQA (Gemini Robotics team) · PlanBench (Valmeekam et al., NeurIPS 2023 D&B) · LLM-Modulo (Kambhampati et al., ICML 2024) · W-MSR (LeBlanc et al., IEEE JSAC 2013) · EigenTrust (Kamvar et al., WWW 2003) · beta-reputation (Jøsang & Ismail, 2002) · SPL (Anderson et al., 2018) · Dawid & Skene (1979) · crowd-kit (Toloka) · Cosmos-Reason2 (NVIDIA) · SO-101 model (MuJoCo Menagerie) · PlotNeuralNet (H. Iqbal) · diagram style after S. Raschka.

@misc{roborace2026,
  title  = {RoboRACE: Byzantine-Robust Multi-Agent Robotics with Receiver-Anchored Channel Estimation},
  author = {Nabidnur},
  year   = {2026},
  note   = {https://github.com/Hisernberg/robotics}
}

This card is generated by scripts/publish_hf.py from the GitHub README, which is generated by scripts/make_readme.py from results/leaderboard.json.

Downloads last month
257

Models trained or fine-tuned on Nabidnur/RoboRACE-Bench

Spaces using Nabidnur/RoboRACE-Bench 2