physicalai-bmi/forge-arm-reach-bc
The Institute for Physical AI's first released policy checkpoint — a small,
open, on-device behavior-cloning controller trained on our own openly
published, browser-generated dataset physicalai-bmi/forge-arm-reach.
It is deliberately tiny (17,923 parameters, ~72 KB) so it runs anywhere — including live in a web page with no server, no GPU, and no install. You can run it on the page at https://physicalai-bmi.org/research/checkpoint.
This is an educational reference policy, not a foundation model. It solves a single reach task in a simulated arm. We release it because the field's bar for "open" should include the weights, the data, and a way to actually run them — and because releasing small honest artifacts is how open science compounds.
What it does
Maps a 7-D observation to a 3-D end-effector delta action for the forge_arm
reach task ("Reach the target with the end effector").
| dims | meaning | |
|---|---|---|
observation.state | 7 | simulator state vector (state_0…state_6) |
action | 3 | end-effector delta control (action_0…action_2) |
Architecture: MLP 7 → 128 → 128 → 3, SiLU activations. Inputs and outputs are
z-scored using stats fit on the training split only (stored in config.json).
Results (honest)
Evaluated on 2 fully held-out episodes (indices 3 and 8) never seen in training — an episode-level split, not a frame-level one:
| metric | value |
|---|---|
| Held-out action MSE | 5.68 × 10⁻⁷ |
| Train action MSE | 5.18 × 10⁻⁷ |
| Predict-the-mean baseline MSE | 4.20 × 10⁻⁴ |
| Variance explained (held-out) | 99.9 % |
Train ≈ val, so no meaningful overfitting. The task is low-dimensional and the expert is scripted, so near-perfect fit is expected — the point is a fully reproducible, released, runnable artifact, not a hard benchmark.
Files
model.safetensors— weights (safetensors)config.json— architecture + normalization stats + metricspolicy.web.json— the same weights as plain float32 arrays for in-browser inference (verified bit-for-bit equivalent to the safetensors forward pass; max abs diff 6.8 × 10⁻⁸)inference.py— minimal NumPy + safetensors example
Use it (Python)
import json, numpy as np
from safetensors.numpy import load_file
w = load_file("model.safetensors"); c = json.load(open("config.json"))
xm, xs = np.array(c["obs_mean"]), np.array(c["obs_std"])
ym, ys = np.array(c["act_mean"]), np.array(c["act_std"])
silu = lambda x: x / (1 + np.exp(-x))
def act(obs):
h = (np.asarray(obs) - xm) / xs
h = silu(w["0.weight"] @ h + w["0.bias"])
h = silu(w["2.weight"] @ h + w["2.bias"])
return (w["4.weight"] @ h + w["4.bias"]) * ys + ym
Use it (browser, no server)
const m = await (await fetch("policy.web.json")).json();
const { obs_mean:xm, obs_std:xs, act_mean:ym, act_std:ys } = m.config, W = m.weights;
const silu = x => x / (1 + Math.exp(-x));
const lin = (Wm, b, v) => Wm.map((row, i) => row.reduce((s, wij, j) => s + wij * v[j], b[i]));
function act(obs) {
let h = obs.map((o, i) => (o - xm[i]) / xs[i]);
h = lin(W["0.weight"], W["0.bias"], h).map(silu);
h = lin(W["2.weight"], W["2.bias"], h).map(silu);
return lin(W["4.weight"], W["4.bias"], h).map((o, i) => o * ys[i] + ym[i]);
}
Training
Deterministic (seed=7), AdamW (lr 2e-3, wd 1e-4), cosine schedule, 4000 steps,
batch 256, best-on-held-out checkpoint. The full script is in the Institute
repository. Reproduce the dataset in ~a minute in your browser at
Forge.
Limitations & intended use
Single simulated task; small dataset (11 episodes); scripted expert; sim-only — sim-to-real transfer needs the usual domain-gap care. Intended for education, imitation-learning baselines, and demonstrating that "open" can mean weights + data + a way to run them. Not safety-tested for any physical deployment.
Citation
@misc{forge_arm_reach_bc_2026,
title = {forge-arm-reach-bc: an on-device behavior-cloning policy},
author = {Institute for Physical AI at Bailey Military Institute},
year = {2026},
howpublished = {\url{https://huggingface.co/physicalai-bmi/forge-arm-reach-bc}}
}
Released under CC-BY-4.0 by the Institute for Physical AI @ BMI.