README.md

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