SimplerEnv

This integration follows the RoboDojo-derived service conventions. Its native delta actions, sensor tracks and final-step scoring remain SimplerEnv-specific.

This benchmark can run as an independent SIM service via server.py. Start from server.example.json, adjust deployment paths/GPU before launch, and follow the shared server workflow. The server owns native reset/control/scoring; the evaluator uses the client, and the model receives only permitted observations. Native service-mode validation is separate from adapter availability.

Evaluate a policy through SimplerEnvBenchmarkAdapter: the model receives only declared observations and returns action chunks; the adapter owns the simulator, controller and native scoring. No model training is required.

Evaluation protocol: fast/full scope, budgets and scoring.
Tasks and variants: 25 aliases, 15 canonical subtasks and native VM/VA matrices.
Policy interface: observations, actions, transport and isolation.
Rendering checks: preflight and graphics-driver troubleshooting.

The prepackaged fast track is executable. Native full VM/VA evaluation is documented but is not yet implemented by the unified adapter; fast results must not be presented as full reference scores.

Directory responsibilities

SimplerEnv/
├── server.py                  # stable public launch entrypoint
├── server.example.json        # example deployment and selected-track settings
├── bench_server/
│   ├── adapter.py             # native bridge, observation allowlist and scoring
│   └── protocol/              # task catalog, selection plan and interface reference
├── environment/               # upstream pins, installation and rendering checks
└── checks/                    # dependency-light integration/boundary checks

bench_server/protocol/ is benchmark definition data, not simulator assets or server credentials. The catalog's bytes and task order are unchanged by this layout migration. plan.py owns task selection. The canonical adapter lives in bench_server/adapter.py and lazily imports the native simulator on reset, solely inside the service process. Model prompts, action selection and results stay under AgentPolicies/<profile>/; benchkit/ supplies shared records, source capture and reports.

Launch the benchmark service

After verifying the native environment, copy server.example.json to your own configuration and select its task, device, observation track and budgets before launch. The example selects the horizontal-can task's native 80-control horizon, interaction_mode: "agent_method" and explicit action-rejection feedback. A method's decision-call cap and action prefix are configured on its driver; they do not extend the native horizon. The separately labeled decision-budget track remains available when explicitly selected. Use a fresh output directory:

On multi-GPU hosts, first run the renderer-only device preflight. Keep its exact device selector and add "expected_gpu_uuid": "GPU-..." (the complete verified UUID) to the server parameters. This optional deployment assertion rejects an unexpected physical device before any public observation; it never silently selects a replacement GPU. CUDA ordinal visibility is not proof of Vulkan device selection.

# Activate the native SimplerEnv environment first; set this secret privately.
export RSI_SIM_SERVER_TOKEN='<32-or-more-character-random-URL-safe-secret>'
python -B -m benchmarks.simBenchmarks.SimplerEnv.server \
  --parameters /absolute/path/to/simpler-server.json \
  --seed 0 --episodes 1 --port 8765 \
  --output-dir /absolute/path/to/AgentPolicies/your_agent/results/simpler_env/raw/your-run/server

The listener binds loopback. Use the shared transport for a trusted driver on another machine. Keep its bearer token and administrative client out of the model actor's workspace. There is no background control tick while the policy is thinking; lost action acknowledgments are not replayed. Each predeclared episode is claimed once, including failures.

The service preserves this benchmark's seven-value delta-action interface; it does not expose RoboDojo's absolute dual-arm EEF16 action or robot-feedback extension. Choose a compatible agent method, not an action-vector conversion guessed by a server. Explicitly select interaction_mode: "agent_method" for methods that use internal inference or local tools over permitted public data, including the current Codex CLI method. This adds /agent-method before /v1 in the selected protocol identity. Omission or "single_response" preserves the historical one-provider-request-per-call track and its existing ID. Neither the service nor the CLI wrapper verifies hidden provider request counts. The new mode grants no extra observations, native access, resets or control budget; see interaction modes.

The example explicitly selects "action_rejection_feedback": true, as required by the current Codex native-vector driver's default feedback behavior. This adds /action-feedback before the optional /agent-method and final /v1 suffixes: a rejected action does not execute, and its bounded validation issue reaches the next counted call with the last acknowledged observation. The omitted/default false setting preserves historical fail-fast semantics. The selected flag is captured in the service parameters; see the protocol.

Install the evaluation environment

Use a Linux NVIDIA node with a separate Python 3.10 environment. From the repository root:

conda env create -f benchmarks/simBenchmarks/SimplerEnv/environment/environment.yml
conda activate starvla-rsi-simpler

export SIMPLERENV_ROOT=/absolute/path/to/benchmarks/SimplerEnv
git clone --recurse-submodules https://github.com/allenai/SimplerEnv.git "$SIMPLERENV_ROOT"
git -C "$SIMPLERENV_ROOT" checkout c701ea271b16b80616d6fed9713c4a50a0adea3b
git -C "$SIMPLERENV_ROOT" submodule update --init --recursive

python -m pip install \
  -c benchmarks/simBenchmarks/SimplerEnv/environment/constraints.txt \
  -e "$SIMPLERENV_ROOT/ManiSkill2_real2sim" -e "$SIMPLERENV_ROOT" -e .

The submodule pin is ef7a4d4fdf4b69f2c2154db5b15b9ac8dfe10682. The adapter checks upstream revisions and tracked modifications before reset. Use the assets shipped with the pinned recursive checkout. Model checkpoints, training data and a StarVLA model server are not required.

The constraints avoid incompatible NumPy/OpenCV combinations and select an available Ruckig wheel. If your deployment requires a network proxy, use its existing configuration; do not put credentials into protocols or model files.

Validate graphics before evaluating a model

CUDA visibility alone is insufficient: the native renderer also needs graphics libraries and a working NVIDIA Vulkan ICD. Prefer your system's NVIDIA ICD. If the graphics library is already installed but the container lacks its ICD registration, this process-local example uses the provided descriptor:

export VK_ICD_FILENAMES="$PWD/benchmarks/simBenchmarks/SimplerEnv/environment/nvidia_icd.json"
python benchmarks/simBenchmarks/SimplerEnv/environment/verify_environment.py

The verifier performs environment/reset/render and constant-action checks, not a model evaluation. Use --help for task and diagnostic-step options. Check both IBL and drawer-task RT rendering: a detailed photographic background can hide a black robot or foreground. RENDERING.md explains this distinction and matching driver-data requirements. Simulator-free catalog or list commands do not establish graphics readiness.

Connect an agent

After service readiness, launch a compatible model-owned driver. For the current Codex native-vector method, follow NATIVE_CONTROL.md. Model configuration, prompts, memory and decision loops belong to that profile, not this benchmark. The service exposes only its declared observation/action contract, not a task-solving RPC or the simulator handle.

See the evaluation workflow for source capture and closed-record reporting. Protocol and call-accounting restrictions apply to each selected method; a method name alone does not establish provider metering or native parity.

Results and offline review

Outputs belong under AgentPolicies/<model-profile>/results/simpler_env/:

raw/: campaigns, manifests, event streams, responses, source snapshots and original media.
reports/ and indices/: task coverage, typed failures and hash-bound summaries.
media/: presentation copies of closed videos, named with task IDs/descriptions.

Raw/media outputs are ignored by Git. Preserve original closed bytes and every attempt, including failures. Do not expose closed artifacts to an active policy.

The primary score uses the final executed native step's success, not a video's appearance, an actor's declaration or the best intermediate frame. Record policy calls, executed action decisions, control steps and first-success timing separately. First success is diagnostic, not a replacement score.

harness_source/ binds shared and benchmark integration bytes; model_source/ separately binds declared policy/configuration/prompt bytes. These are provenance records, not proof of OS isolation, loaded-memory identity, native asset completeness or trusted provider accounting.

Use the shared closed-record auditor, mailbox artifact auditor and progress reporter on closed runs only. Their --help commands describe supported inputs and limitations. A passed record audit does not establish native baseline parity. Changing code or setup requires a separately declared evaluation configuration, never rewritten results.

Use the review checklist for independent closed-run review. Shared video export is available as python -m benchkit.reports.export_videos --help; it copies only closed evidence. Historical anonymous results remain under the model result namespace, not in this benchmark's source directory.