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. Model checkpoints (the frozen PPO backbones and reference adaptation methods that generated these logs): 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.

Citation

@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. If you use the ManiSkill baselines this data was generated from, cite ManiSkill separately.