forge-arm-reach-bc

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").

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:

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 + metrics
• policy.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.