--- license: mit task_categories: - reinforcement-learning - robotics tags: - robot-manipulation - action-interface - domain-adaptation - benchmark - maniskill - system-identification - belief-adaptation - sim-to-real pretty_name: ActionShift --- # ActionShift Frozen splits, eval configs, and rollout logs for **ActionShift**, a benchmark that measures whether a manipulation policy can adapt to a hidden action-interface contract without ever being told which contract is active. Code: [github.com/Archerkattri/actionshift](https://github.com/Archerkattri/actionshift). Model checkpoints (the frozen PPO backbones and reference adaptation methods that generated these logs): [kattri15/actionshift-baselines](https://huggingface.co/kattri15/actionshift-baselines). ## What is an "action-interface contract" here A policy emits an action vector every control step. The contract is the mapping from that vector to controller behavior: which channel drives which joint (`permutation`), per-channel direction (`sign`), per-channel gain (`scale`), delta-vs-absolute encoding (`target`), reference frame (`frame`), execution delay in steps (`lag`), and gripper polarity (`gripper_inverted`). ActionShift holds task dynamics fixed and varies only this contract, so any drop in success is attributable to the interface and nothing else. The declared contract grammar/product space for the tournament backbones is `configs/contracts/core.yaml` (32 contracts: 2 permutations x 4 signs x 2 scales x 2 lags, target and frame fixed). ## The 5 splits Splits are preregistered, seeded, and hash-addressed: each manifest carries a `manifest_sha256` and every listed contract carries its own `sha256`, so disjointness between splits is test-enforced rather than asserted. Generator: `split-v1`, seed `20260718`. | Split | Manifest | Rule | |---|---|---| | `seen` | `configs/split/manifests/seen.json` | contracts the tournament backbones were evaluated on inside the declared pool | | `unseen_value` | `configs/split/manifests/unseen_value.json` | field values absent from the seen set | | `unseen_composition` | `configs/split/manifests/unseen_composition.json` | field-value combinations absent from the seen set, zero contract- and composition-signature overlap with training | | `long_lag` | `configs/split/manifests/long_lag.json` | longer execution delay than any seen contract | | `task_transfer` | `configs/split/manifests/task_transfer.json` | held out across task family | Each `configs/split/*.yaml` is the split definition (name, seed, generator version, pointer to its manifest, `require_disjoint_contracts: true`); each `configs/split/manifests/*.json` is the materialized, hash-addressed contract list that definition resolves to. ## Contents ``` configs/split/manifests/*.json 5 frozen split manifests (contract lists, sha256-addressed) configs/split/*.yaml 5 split definitions (seed, generator, disjointness requirement) configs/contracts/core.yaml the contract grammar / product-space manifest the tournament draws from configs/task/*.yaml task configs (pick_cube, push_cube, peg_insertion_side) configs/evaluation/headline.yaml headline eval sweep: backend, seeds, tasks, splits, methods, episode budget configs/method/*.yaml per-method configs (oracle, no_adapt, probes, OSI, RMA, DualABI variants) experiments/manifests/headline.jsonl materialized headline evaluation job matrix artifacts/**/gate1/*oracle*.jsonl privileged-oracle rollout logs, Gate 1 slice (see below) artifacts/**/gate0/parity/*oracle_nonidentity.jsonl privileged-oracle parity checks, Gate 0 artifacts/**/jobs.jsonl, *verdict*.json run ledgers: job id, seed, checkpoint sha256, Wilson/paired-bootstrap verdicts ``` ## Privileged-oracle rollout logs `artifacts/sprint/gate1/`, `artifacts/third_task/gate1/`, `artifacts/fourth_task/gate1/` hold the Gate 1 oracle rollouts for the four competence-gated tasks (pick_cube, push_cube, pull_cube, stack_cube). The oracle path knows the true active contract and encodes the canonical policy action before the hidden wrapper executes it, so it measures the instantaneous ceiling: how well the frozen backbone does when contract knowledge is free. Each file is one (task, split, seed) cell, 100 episodes per contract, two contracts per cell. `jobs.jsonl` in each `sprint/gate1/` directory ties every rollout file to the exact checkpoint `sha256` that produced it. `gate0/parity/*oracle_nonidentity.jsonl` are the earlier parity checks (does the oracle path stay near-ceiling under a non-identity contract) that gated a task into the tournament in the first place. Headline oracle result on the real ManiSkill simulator (600 episodes/cell, Wilson 95% CI, `reports/gate1.md` on GitHub): Pick/seen 1.000 [0.994, 1.000], Push/seen 1.000 [0.994, 1.000], both collapsing the no-adapt floor to ~0. The oracle path does **not** rescue the `long_lag` split (Pick 0.027 [0.016, 0.043], Push 0.153 [0.127, 0.184]) — contract knowledge alone is insufficient against execution delay, which is why a separate delay-aware backbone exists (see the model repo). ## How these logs were generated The pinned official ManiSkill v3.0.1 baselines (PPO, control mode `pd_ee_delta_pose`) were trained per task, then evaluated through a software action-interface wrapper that composes the seven contract fields. Every oracle rollout row is one episode: seed, contract fields, per-step observations are not retained, episode outcome and success are. Full generation code and the wrapper implementation are in the GitHub repo (not mirrored here). ## Honest limits - **Sim-only, no hardware.** Every number here comes from ManiSkill (SAPIEN/PhysX) simulation. No claim is made about real-robot transfer of these specific contracts or rollouts. - **Four tasks, one control mode.** pick_cube, push_cube, pull_cube, stack_cube, all `pd_ee_delta_pose`. peg_insertion_side is excluded on backbone competence (did not clear the Gate 0 floor at the official training budget); its Gate 0 parity log is included for the record, not as a competent-task result. - **The oracle is a ceiling, not a target.** It is privileged (it is told the active contract) and is reported as an upper bound for the adaptation methods, not a method to beat. - **`long_lag` breaks the oracle too.** Do not read `long_lag` numbers as "contract knowledge fixes everything" — see above. ## We are not aware of a prior benchmark isolating the action-interface contract this way Manipulation benchmarks with domain randomization vary dynamics (mass, friction, visual appearance). Sim-to-real and system-identification work generally targets physical parameters, not the software mapping from policy output to controller command. After checking ASID and Dynamics-as-Prompts (the nearest system-identification-for-control comparators) and the standard ManiSkill/robomimic benchmark lines, we did not find a prior benchmark that holds task dynamics fixed and varies only a compositional action-interface contract (permutation/sign/scale/target/frame/lag/gripper) with frozen, hash-addressed, disjointness-enforced splits and a privileged-oracle ceiling. This is a scoped claim about what we checked, not a claim of exhaustive prior-art search. ## License MIT, same as the code and paper. See `LICENSE` in the [GitHub repo](https://github.com/Archerkattri/actionshift). ## Citation ```bibtex @software{attri2026actionshift, author = {Attri, Krishi}, title = {ActionShift: Hidden compositional action-interface adaptation benchmark}, year = {2026}, publisher = {Zenodo}, doi = {10.5281/zenodo.21500713}, url = {https://github.com/Archerkattri/actionshift} } ``` Zenodo DOI: [10.5281/zenodo.21500713](https://doi.org/10.5281/zenodo.21500713). If you use the ManiSkill baselines this data was generated from, cite ManiSkill separately.