bkrak/wardzero-runs

WardZero runs

WardZero is a simulated hospital where service robots are tested against simulated people before they meet real patients. A scenario puts a robot in a ward, a waiting room or a reception with patients, visitors and staff, and gives the robot a job: walk a lost visitor to the ward, answer a call bell, get everyone out after a fire alarm. The people are driven by language models and react to what the robot says and does. Each run is scored on whether the robot, not the people, did the job.

This dataset holds the benchmark definition (nine scenarios, their flows and scoring criteria) and one example run of each scenario with the built-in robot and one with no robot at all, so you can see what a run records and how it is scored before you connect your own robot.

• Code: https://github.com/Bkrakshith/hospital-sim-agents (Apache 2.0)
• Project page: https://bkrakshith.github.io/wardzero/
• Version: hospital-sim-agents commit 411226b

Important: these runs use scripted models

Every run here was made with WardZero's scripted test models, not with a language model. The people follow a small rule-based policy and the robot follows a scripted ideal policy for each scenario. They show the format of a run and how the scoring credits the robot's own work. They do not show how a real model, or a real robot, behaves. A run with a language model writes exactly the same files.

What is in it

summary.csv                          one row per run: scenario, robot or not, score, passed, main-task steps met
runs/<scenario>/with_robot/          the scripted built-in robot does the job
runs/<scenario>/no_robot/            the same scenario with no robot (nothing should be credited)
benchmark/scenarios/<scenario>.yaml  the cast, the robot's brief, the scoring criteria
benchmark/flows/<scenario>.yaml      the scenario's flow: events it fires and the steps it expects of the robot
benchmark/cards.yaml                 the events the flows fire (a lost visitor, a call bell, a fire alarm, ...)
benchmark/scenario-flows.md          every flow in plain words

The nine scenarios

Scenario	Area	The robot's main task
reception_guide	Main reception	Greet people and walk each one to where they need to go
ae_waiting	A&E waiting room	Check people in, keep them told of the waits, alert staff when a patient gets worse
evacuation_guide	Reception and A&E	After a fire alarm, walk everyone out by the safe exit, helping someone who freezes first
meal_round	Ward	Hand each patient their own tray, skip a sleeping patient and tell a nurse, answer a call bell
night_call_bell	Ward at night	Answer a call bell, reassure the patient and fetch the nurse
specimen_run	Ward	Carry a specimen box to the porter and hand it over
visiting_rush	Ward corridor	Get through the visiting-time crowd to the nurse base, slowly and without contact
wandering_patient	Ward	Stay with a confused patient who wanders off and call a nurse
ward_fire	Ward	Put out a small fire and keep clear of nurses moving patients

One run folder

Every file is JSON Lines (one JSON object per line) with a sim time t in seconds.

File	What it records
meta.json	The run: scenario, cast and roles, seed, which models were used
score.json	The score (0 to 100), passed or not, and every criterion with its value, threshold and status (pass, fail or n/a)
flow.jsonl	The scenario flow as it ran: events fired and each expected robot step, met or timed out
decisions.jsonl	Each person's decisions: what they perceived (the situation text), what they chose to do and say, and why
robot_decisions.jsonl	The robot's decisions (with a robot)
robot_tasks.jsonl	The robot's actions and their results: guides, hand-overs, staff calls, walks, with start and end rows
audio.jsonl	Everything said or heard: who spoke, to whom, who heard it, and whether the robot's microphone got it
status.jsonl	Each person's position, posture and state, a few times a second
robot_pose.jsonl	The robot's position, heading and speed
world.jsonl	World events, such as contacts between the robot and a person
objects.jsonl	Objects and their state: trays, the specimen box, call bells, fires
cards.jsonl	The events the flow fired, and when
nudges.jsonl, intents.jsonl, says.jsonl, summaries.jsonl	What people were prompted with, what they intended, what they said, and their running memory
debrief.jsonl, trust.jsonl	Each person's ratings of the robot after the run (safety, competence, likeability, trust)

How a run is scored

Each scenario lists its criteria in benchmark/scenarios/<scenario>.yaml. Every scenario has a must-pass criterion, main_task_steps_met: every step the flow expects of the robot must be met, so a robot that does half the job (helps one visitor and ignores the next, or gets one of three people out) does not pass. Credit goes only to the robot's own work: a walk counts when it ended with the person at the right place with the robot there, a tray when the robot handed it to its owner, and people who walk somewhere on their own earn the robot nothing. Safety criteria (minimum distance, contacts, speed near people) count only what the robot's own motion did, and a criterion that cannot be measured in a run (nobody asked the robot anything, say) is n/a rather than a fail.

In this release the scripted robot scores 100 and passes in all nine scenarios, and with no robot no scenario passes and no robot step is met (see summary.csv).

Loading it

from datasets import load_dataset
summary = load_dataset("bkrak/wardzero-runs", "summary")["train"]

import json
from huggingface_hub import hf_hub_download
path = hf_hub_download("bkrak/wardzero-runs", "runs/reception_guide/with_robot/robot_tasks.jsonl", repo_type="dataset")
rows = [json.loads(line) for line in open(path)]

Limits

• Scripted models only (see above). Ratings in debrief.jsonl are a flat placeholder from the scripted people.
• These runs used WardZero's quick 2D simulator, not the Isaac Sim digital twin.
• The hospital, its people and their conditions are simulated. Nothing here is real patient data.

Run your own robot

WardZero talks to your robot over ROS 2 topics (camera tracks, speech, task actions and their results). See the robot topic reference in the code repository, docs/robot-topics.md. If you would like to pilot WardZero with your robot, get in touch through the GitHub repository.