Can a few successful and failed trials tell a frozen robot action model what to change—and when?

SteerAct uses a pretrained sparse autoencoder (SAE) to expose internal features and their steering directions. A shared temporal descriptor summarizes how each feature's activity rises, falls, or fluctuates, allowing comparisons across rollouts without aligning individual timesteps.

• Before steering — select what to change. Use successful and failed reference rollouts to rank features by outcome separation and construct task-specific reference banks.
• During execution — decide when to intervene. Compare the observed feature history with these banks. Intervene only when the history has sufficient reference support and resembles failure.
• When intervention is enabled — choose a signed correction. Search a bounded set of coefficients for an edit that moves the predicted descriptor closer to successful references. Keep the action model and SAE frozen.

The paper studies single-feature steering using 24 outcome-labeled reference rollouts per task, across VLA and WAM backbones. See the project page for the paper's broader evaluation and robot videos.

Current code scope. This folder provides collection, SAE training, feature ranking, and steering evaluation for π₀.₅ and Fast-WAM on nine RoboTwin 2.0 tasks. It requires external simulator/model integrations and checkpoints; it is not a self-contained reproduction of every paper experiment. See Release Scope.

Single-feature setting. The supplied recipes currently set steering.top_k to 4. To use the paper's single-feature formulation, set it to 1 before running rank and infer. This is separate from sae.top_k = 100, which controls SAE sparsity. No configuration files are changed by this README.

Use the Linux/CUDA environment for your selected RoboTwin model integration. Install its simulator assets, model dependencies, and compatible source checkouts first. The exact integration files required by this package are listed under External integrations.

The Python package requires Python ≥ 3.10, NumPy ≥ 1.24, PyTorch ≥ 2.1, and huggingface_hub ≥ 0.20. Once these are available in the model environment, install this package without changing that environment's dependency versions:

cd /path/to/SteerAct
python -m pip install -e . --no-deps
python -m steeract --help

--no-deps assumes the declared dependencies are already installed; it does not install the simulator or either action model. Collection and policy inference require CUDA as currently implemented. --device cpu can be used for offline SAE training/ranking, but does not move the robot policy to CPU.

For the shared-SAE setup, start with an all_tasks recipe:

STEERACT_CONFIG=configs/pi05_all_tasks.json
# For Fast-WAM instead:
# STEERACT_CONFIG=configs/fastwam_all_tasks.json

Before proceeding, edit the selected JSON file:

1. Replace the checkpoint and normalization/statistics placeholders with your actual assets.
2. Set the RoboTwin checkout path, and the Fast-WAM checkout path if applicable.
3. Choose a fresh paths.run_dir for generated artifacts.
4. Set steering.top_k to 1 for the paper's single-feature setting.

All local paths are resolved relative to the JSON file, not the shell's working directory. Absolute paths are recommended. See Configuration for required fields.

Inspect the resolved recipe:

python -m steeract collect --config "$STEERACT_CONFIG" --dry-run

A dry run checks configuration structure only. It does not verify that checkpoints, simulator assets, dependencies, or external adapters exist.

Run these commands from the repository root in the prepared model environment:

# Collect outcome-labeled rollouts and hidden activations.
CUDA_VISIBLE_DEVICES=0 python -m steeract collect --config "$STEERACT_CONFIG"

# Train the SAE on the collected activations.
CUDA_VISIBLE_DEVICES=0 python -m steeract train --config "$STEERACT_CONFIG" --device cuda:0

# Select steering features and construct task-specific reference banks.
CUDA_VISIBLE_DEVICES=0 python -m steeract rank --config "$STEERACT_CONFIG" --device cuda:0

# Evaluate the frozen action model with online steering.
CUDA_VISIBLE_DEVICES=0 python -m steeract infer --config "$STEERACT_CONFIG" --device cuda:0

The same sequence supports all four supplied recipes. For a smaller initial run, choose a single_task recipe; it trains a task-specific SAE rather than the shared SAE used by the all_tasks setup.

all_tasks pools 216 reference rollouts to train one SAE at the selected layer for the selected backbone. Feature selection and reference banks remain task-specific. The current loader accepts exactly one registered task or all nine, not arbitrary task subsets.

Fast-WAM's hf:// entries are resolved through Hugging Face Hub and may download large model assets. They do not supply the task checkpoint or dataset statistics. Checkpoint architecture, policy.config_name where applicable, embodiment, and normalization/statistics must agree.

put_bottles_dustbin
stack_blocks_three
blocks_ranking_size
place_dual_shoes
dump_bin_bigbin
open_microwave
turn_switch
place_mouse_pad
pick_diverse_bottles

Each reference rollout must contain at least five decisions, so both triple spacings can be represented. Each task must provide at least two successful and two failed rollouts for feature ranking. Collection does not balance outcomes automatically: 24 collected rollouts alone do not guarantee a usable split. Inspect the collected outcomes before training/ranking; use a new collection recipe/run if the split is insufficient.

The SAE defaults are a dictionary of size 8 × hidden dimension, TopK sparsity k = 100 (at most 100 nonzero entries per token), 15,000 training steps, batch size 1,024, and learning rate 3 × 10⁻⁴. The SAE is then frozen for feature selection and steering; the pretrained action model is not fine-tuned by any of these four stages.

Each feature history is summarized by an 18-dimensional descriptor: for each of two spacings, six local order-pattern frequencies, normalized entropy, tie frequency, and an availability indicator. Reference-bank separation identifies candidate steering features.

During execution, the Support Gate checks whether the history provides sufficient evidence for comparison, and the Failure Gate checks whether it is closer to failed references. When both gates are open, a bounded search chooses a signed coefficient using predicted improvement toward the success bank. The controller re-encodes the edited activations and records the measured result for the next decision.

For steering.top_k > 1, the implementation averages selected features' intensity histories and decoder directions, then uses one aggregate bank and one coefficient. It does not run independent controllers for each feature.

• Held-out seeds: recipes use 24 reference episodes/task starting at seed 0 and 200 evaluation episodes/task starting at seed 5000. Collection and evaluation seed ranges must not overlap.
• Step limits: evaluation.max_steps_multiplier defaults to 2. Match evaluation horizons and budgets when comparing against unsteered policies or external baselines.
• Recipe changes: changing the backbone, tasks, selected layer, collection settings, policy settings, or source-asset paths changes the collection identity. Use a fresh run directory and regenerate compatible artifacts.
• Steering changes: after changing steering.top_k or controller settings, rerun rank before infer. Existing evaluation directories reject incompatible configurations. For new controller/evaluation settings at the same feature count, archive or rename the existing results/top<k>/ directory before rerunning; keep the compatible SAE and bank in place. Changing run_dir alone does not move those inputs.
• Collection errors: invalid/too-short episodes and backend exceptions are logged and raised. max_attempts is not an automatic recovery mechanism for these errors.

Generated artifacts are written under paths.run_dir:

<run_dir>/
├── activations/
│   ├── manifest.json            # Recipe identity and collected episodes
│   └── ...                      # Per-task, per-episode activation shards
├── sae/
│   ├── model.pt                 # Frozen SAE used by rank and infer
│   └── training.json
├── ranking/
│   └── <task>.json              # Feature scores and selection
├── steering_bank.json           # Task-specific references and controller settings
└── results/
    └── top<k>/                  # top1 for single-feature steering; supplied default: top4
        ├── configuration.json
        ├── episodes.jsonl
        ├── summary.json
        └── traces/

Success rates in summary.json are stored as fractions in [0, 1]; multiply by 100 for percentages. The macro-average weights each evaluated task equally.

The backend adapters expect the following specific source layout. A generic RoboTwin installation is not sufficient unless it includes these integrations:

<paths.robotwin>/
├── scripts/eval_policy_xpolicylab.py          # Both backbones
├── description/task_instruction/<task>.json  # π₀.₅ task instructions
└── XPolicyLab/                              # π₀.₅
    ├── policy/Pi_05/model.py
    ├── policy/Pi_05/openpi/src/
    └── utils/process_data.py

<paths.fastwam>/                             # Fast-WAM
├── experiments/robotwin/fastwam_policy/deploy_policy.py
└── configs/sim_robotwin.yaml

The π₀.₅ adapter expects 18 PaliGemma layers, 18 action-expert layers, and task-instruction JSON files containing full_description. The Fast-WAM adapter expects 30 video blocks, 30 action blocks, and the model.mot._apply_expert_post_block_tensor interception API. Exact compatible source revisions are not pinned in this folder; verify these interfaces before launching an experiment.

Use python -m steeract for the workflow documented here. The separate SAE/ directory contains legacy wrappers that depend on an external SAE/sae_pipeline checkout and use different defaults and artifact formats. Its checkpoints and banks should not be mixed with those produced by steeract/.

If you find SteerAct useful, please cite the paper.

@misc{zhou2026steeract,
  title   = {SteerAct: Unlocking Action Models through Few-Shot Temporal Steering},
  author  = {Kaichen Zhou and Zhiyan Li and Chongkai Gao and Yuhan Wang and
             Wenlong Huang and Maggie Wang and Fangneng Zhan and Manling Li and
             Qianqian Wang and Mac Schwager and Zhuang Liu and Li Fei-Fei and
             Mengyu Wang and Paul Pu Liang},
  year    = {2026},
  eprint  = {2610.25632},
  archivePrefix = {arXiv},
  primaryClass = {cs.RO},
  url     = {https://arxiv.org/abs/2610.25632}
}

Project Page · Method Overview · Robot Demonstrations