SimReadyBench

A benchmark for simulation-ready asset reconstruction

Chris von Csefalvay, Pranav Doma, Achyuthan Unni Krishnan and Tamas Foldi

HCLTech

SimReadyBench tests whether AI agents can reconstruct simulation-ready OpenUSD objects from one image, an object description and dimensions. NV100 contains 100 objects with their source assets, task inputs and evaluation data.

Formal fidelity is the primary score: it measures structural, physical and semantic compliance with the SimReady profile. Visual fidelity measures geometry and appearance together. Kinematic fidelity measures articulation separately. All three use a 0–100 scale; there is no combined overall score.

Browse the NV100 results · Reference objects · Run the Harbor tasks

NV100 leaderboard

One final reconstruction per object, across all 100 objects. The completed run below used evaluator 2.1.0 and Codex 0.164.0.

Model	Formal (%)	Visual (%)	Kinematic (%)	Total tokens	Estimated model cost (USD)	Cost/item (USD)
GPT-6.1 Terra	90.94	47.02–47.63	1.10	40,500,989	10.49	0.1049

Formal and kinematic values are means over 100 objects. Visual fidelity is measured for 99 objects; its mean over those objects is 47.50. The table gives lower and upper bounds for the full 100-object visual mean, not a confidence interval. Token and cost totals include the six additional verifier-timeout attempts. Cost/item divides the total estimated model cost by 100 objects; hosted compute is not included.

Per-object results · Attempt history · Candidate packages, renders and trajectories · Harbor run

Scores

Formal fidelity

The primary compliance score uses the 46 mandatory requirements of NVIDIA SimReady Robotics-Prop 4.0.0:

Formal = 95 × passed mandatory requirements / 46
         + 5 if all 46 requirements pass

The requirements cover hierarchy, naming, units, mesh properties, materials, semantics, collision and rigid-body configuration, and thumbnail metadata. Each requirement counts once, regardless of how many findings it produces. A score of 100 requires all 46 to pass. Optional requirements are reported separately and do not alter formal fidelity.

Visual fidelity

Visual fidelity combines geometry similarity G with rendered appearance similarity A:

Visual = sqrt(G × A)
Appearance = mean(four foreground RGB SSIM scores)

Each appearance score is structural similarity (SSIM) over the union of reference and candidate foreground pixels, clipped to 0–1 and expressed as a percentage. The four fixed comparison views use a shared whole-object alignment. Appearance is a component of visual fidelity, not an alternative name for it.

Geometry measures bidirectional surface agreement at the reference scale, without scale fitting. Evaluator 2.1.0, used for the leaderboard above, computes the surface F-score from thresholded precision and recall. Evaluator 2.2.0 uses 65,536 area-weighted surface samples per object: directional credit is mean(1 / (1 + (distance / band)^2)), with a band of 2% of the reference cloud's 1st–99th-percentile bounding-box diagonal. G is 100 times the harmonic mean of the two directional credits. Results retain their evaluator version.

Kinematic fidelity

Kinematic fidelity measures recovered joints and the relative motion their constraints permit. Matched joint quality combines motion agreement, travel-range agreement and limit-pattern agreement. Missing joints lose credit; extra joints increase the denominator.

Group score = 100 × 2 × sum(matched joint quality)
              / (reference joint count + candidate joint count)

Moving joints and fixed constraints are scored separately. Their geometric mean gives kinematic fidelity when both groups apply; a single applicable group supplies the score directly. Motion is compared at 17 deterministic probe states on common reference-body landmarks.

Reports preserve unknown measurements as null, with coverage and lower/upper bounds. A failed requirement is distinct from a measurement that could not be completed.

Run NV100 with Harbor

For local execution, use Linux x86_64, Python 3.12, Docker Engine and Docker Compose. Tasks request four CPUs and 8 GiB for the agent environment, with a separate four-CPU, 16 GiB verifier. Choose concurrency to fit the host.

python3.12 -m venv .venv
. .venv/bin/activate
python -m pip install harbor==0.24.0
harbor auth login

Set the credentials required by your model provider, such as OPENAI_API_KEY for OpenAI. Select the agent and model, then run all 100 tasks and upload the results:

AGENT=codex
MODEL=openai/gpt-6.1-terra

harbor run \
  -d hcltech-robotics/simreadybench \
  -a "$AGENT" -m "$MODEL" \
  --n-attempts 1 --n-concurrent 1 \
  --max-retries 3 --upload

Change AGENT and MODEL for another supported agent. --n-attempts sets scored attempts per task; --max-retries limits exception retries. Increase --n-concurrent for parallel execution. --upload sends trial results, trajectories and artefacts to Harbor Hub; uploads are private by default.

Use the same command with --dry-run to check the configuration without running trials. Unversioned dataset names select the latest release, currently evaluator 2.2.0. The leaderboard remains the measured 2.1.0 run. For hosted execution and provider-secret configuration, see Harbor's run guide.

Each task supplies one observation image and its brief. The agent authors a self-contained package with asset.usd at its root and can request up to five formal-validation feedback calls. Final visual evaluation uses four separate comparison views. Complete trajectories are required; retrieving or importing external USD assets is a protocol failure. Locally authored USD and task-provided inputs are allowed.

Use the data

The references/nv100 split contains object names, descriptions, dimensions through task briefs, observation images and source-package links. The default results/test split contains final reconstruction results. Join a result's reference_id to the reference row's stable id.

from datasets import load_dataset

repo = "hcltech-robotics/simreadybench"
references = load_dataset(repo, "references", split="nv100")
results = load_dataset(repo, "results", split="test")
by_id = {row["id"]: row for row in references}
reference = by_id[results[0]["reference_id"]]

Rows link to submitted USD packages and dependencies, previews, complete score reports, rewards and sanitized native/ATIF trajectories. The result_attempts/test split includes retries; is_final_attempt and included_in_leaderboard distinguish the scored reconstructions. Download USD dependencies together with the entry point.

Benchmark code is MIT-licensed. NVIDIA source assets retain their CC BY 4.0 licence and attribution.

Citation

@software{simreadybench2026,
  title = {SimReadyBench: Evaluating models, harnesses and skills
           for simulation-ready asset generation},
  author = {von Csefalvay, Chris and Doma, Pranav and
            Unni Krishnan, Achyuthan and Foldi, Tamas},
  organization = {HCLTech},
  year = {2026},
  version = {1.0.0},
  url = {https://github.com/hcltech-robotics/simreadybench}
}