Harness VLA: Steering Frozen VLAs into Reliable Manipulation Primitives via Memory-Guided Agents

Harness VLA: Steering Frozen VLAs into Reliable Manipulation Primitives via Memory-Guided Agents

Paper: Harness VLA: Steering Frozen VLAs into Reliable Manipulation Primitives via Memory-Guided Agents · Yixian Zhang*, Huanming Zhang*, Feng Gao, Xiao Li, Zhihao Liu, Yi Nie, Chunyang Zhu, Jiaxing Qiu, Yuchen Yan, Jiyuan Liu, Wenhao Tang, Jiaji Rao, Zhengru Fang, Changxu Wei, Yu Wang, Wenbo Ding†, Chao Yu† · Tsinghua University / Striding AI / Purdue University / Institute of Automation, CAS / Infinigence AI / HKUST / Zhongguancun Academy · arXiv:2607.08448v4 (revised 2026-09-02) · Project page harnessvla.github.io · Code released: github.com/RLinf/RPent

In one sentence: the paper touches no VLA weight at all. It demotes a frozen VLA from "policy that runs the whole episode" to "one retryable contact-rich primitive called vla_act", and lets an LLM coding agent orchestrate it against a fixed library of six analytic primitives plus memory. On LIBERO-Pro that buys +38.6 points over the strongest reported baseline; on RoboCasa365, +27.1.

1. Two Paradigms, Both Mis-Assigning Responsibility

Language-conditioned manipulation is being attacked from two opposite ends. End-to-end Vision-Language-Action models learn contact-rich visuomotor control straight from robot trajectories. LLM coding agents use language-model reasoning to compose explicit perception-and-control APIs. The paper's diagnosis of both is blunt: each paradigm is powerful, but each assigns the wrong component too much responsibility. A monolithic VLA has to absorb language grounding, long-horizon composition and low-level control inside a single policy. A coding agent has to realize physically delicate interaction through hand-designed or agent-generated APIs.

The VLA side has moved fast. RT-1 and Octo opened the generalist-policy line, RT-2 and the Open X-Embodiment release scaled it through cross-embodiment co-training, OpenVLA opened the paradigm up by pairing a Prismatic-style VLM with a Llama-2 action tokenizer, and the flow-matching $\pi_0$ and $\pi_{0.5}$ models reported substantial gains from heterogeneous co-training and out-of-distribution language. GR00T and Gemini Robotics continue scaling toward humanoid and general-purpose embodiments. What these models are genuinely good at is local, image-conditioned contact: grasping irregular objects, placing under tight tolerance, actuating fixtures that are brittle for analytic controllers.

What they are bad at is equally well characterized: deployment outside the trajectory distribution they were trained on. A model trained on in-distribution task trajectories may know how to grasp a milk carton or turn a faucet, yet fail when semantic targets are redirected, when goal predicates are re-bound, when object layouts shift, or when short skills must be composed into longer routines. The terminal-state frames in the paper's Figure 3 make this concrete. Under Object-Pro instruction redirection, the visual scene stays similar while the instruction has moved the target, and $\pi_{\mathrm{RLinf}}$ repeats the standard behavior instead of following the new description. Under Goal-Pro position swap, the layout changes and the policy still moves the object toward the training-time region. The language channel of such policies is, to a large degree, vestigial.

The coding-agent side has the mirror problem. Code as Policies and ProgPrompt recast robot control as program synthesis over curated perception and motion APIs. RoboCodeX, ViperGPT and VisProg extended this to multimodal program synthesis; more recent agentic variants add richer perception, tool use, feedback and persistent execution state. But scaling such systems in manipulation has usually meant expanding the primitive or skill library. And purely analytic primitives — deterministic kinematic or model-based controllers such as IK transport, wrist rotation, base motion, gripper opening and release — remain poorly suited to irregular grasping, constrained placement and articulated-object manipulation.

The counter-thesis here is to keep the primitive library fixed and small, and let the agent learn how to orchestrate it. The intellectual borrowing is from software-engineering agents: SWE-agent and OpenHands formalize harnesses for iterative editing, execution and feedback, and executable code has empirically been a strong action representation for LLM agents. This paper takes the harness principle — structured interfaces, persistent state, execution feedback, memory — rather than the requirement that actions be represented as code.

Figure 1 (paper Figure 2): deployment perturbations expand the reachable task configurations beyond the in-distribution trajectories covered by the frozen VLA. A direct VLA rollout may try to bridge the perturbed space and fail before reaching the target. Harness VLA instead decomposes the task into local contact-rich VLA invocations plus analytic primitive control: analytic primitives perceive the current target, re-ground task bindings, and move the robot between VLA-compatible local regions, while vla_act fires only for contact-rich phases inside those regions.

2. Formalization: a Turn-Based Agentic Execution Loop

The environment $\mathcal{E}$ is driven by a rigid-body physics engine (MuJoCo via Robosuite in the implementation). At each timestep $t$ it exposes a multimodal observation tuple:

$$o_{t}=\left(I_{t}^{\text{rgb}},\,I_{t}^{\text{d}},\,q_{t}\right)$$

where $I_{t}^{\text{rgb}}$ is an agent-view RGB image, $I_{t}^{\text{d}}$ is a co-aligned metric depth map, and $q_{t}$ is the robot proprioceptive state, concatenating end-effector pose and gripper state. A task is a natural-language description $\ell$ together with a binary completion predicate $\mathcal{G}$, exposed only as a sparse success signal at episode termination.

The decisive formalization choice is that the visuomotor policy is not treated as a separate hierarchical tier. All low-level control mechanisms — the frozen pretrained VLA $f_{\theta}$ and every deterministic operational-space controller — are unified into a single predefined primitive library $\mathcal{P}$. An episode is then an autoregressive, turn-based interaction between a high-level agentic planner $\Pi$ and the physics engine. At each execution turn $t$ the planner consumes $o_t$, $\ell$, and retrieved context from Task Specific Memory and Global Memory, and emits one structured JSON invocation of a selected primitive:

$$c_{t}\in\mathcal{P},\qquad c_{t}=\{\texttt{action},\ \texttt{args}\}$$

The physics engine receives the invocation directly and executes the corresponding physical motion until the primitive's internal post-condition is met. On termination it yields the next observation $o_{t+1}$ and updated robot state $q_{t+1}$. The environment-planner loop iterates until the goal predicate $\mathcal{G}$ is satisfied or a maximum step budget is exhausted.

One constraint is easy to miss and load-bearing: the planner never emits low-level torques, joint targets or action chunks directly. It selects a primitive and binds its arguments from language, RGB-D observation, proprioception and memory. The whole action space collapses into a closed, auditable JSON contract.

3. The Harness: Two-Phase Agent Lifecycle

Harness VLA packages robot manipulation in the same REPL-style form used by coding agents. The harness is the runtime contract between planner and environment: it exposes primitive schemas, serializes decisions as JSON commands, executes primitives, refreshes RGB-D and proprioceptive observations, logs traces, retrieves both memory modules, enforces reset and budget policies, and checks progress through the benchmark predicate. Because the harness delegates all fine-grained execution to the primitive library, the planner is free to focus entirely on compositional reasoning, leaning on the RGB channel for qualitative scene reasoning (clutter, semantic identity) and on the co-aligned depth map plus proprioception for metric localization.

The agent lifecycle inside the harness splits into two phases, and that split is the skeleton of the whole experimental protocol.

Exploratory Bootstrapping. Operating on a single reference instantiation of a task, the agent interacts autonomously with the environment to discover a working solution. In this phase the planner is uniquely granted a reset primitive and runs under a generous wall-clock budget. Because the primitive vocabulary is fixed, exploration concentrates entirely on iterative composition: trying different staging orders, pre-contact poses, invocation timings for vla_act, and early-return termination thresholds, observing the physical effect of each call, and correcting course on failure.

Deployment Evaluation. Formal evaluation on unseen environment variations — position swaps, instruction redirections, multiple initial-state seeds — imposes a strict execution regime. The reset primitive is completely disabled and the operational step budget is significantly shortened. The planner retrieves the pre-computed JSONL trace from Task Specific Memory, grounds it dynamically from live RGB-D observation, and executes deterministically while referencing the success rules and failure models accumulated in Global Memory. Every benchmark number reported in the paper comes from this strict phase.

Task success is always decided by the benchmark-provided binary completion predicate. Primitive-level post-conditions — the return condition of vla_act or release — only determine when an individual primitive hands control back to the planner and are never substituted for the final task predicate. Without that separation, "it looks grasped" would silently be logged as success.

Figure 2 (paper Figure 1): system overview. Given a task description, RGB-D observations and robot state, the agentic planner selects structured calls from a fixed primitive library rather than emitting low-level actions directly. The library exposes the frozen VLA as vla_act for contact-rich behavior and uses analytic primitives such as move_to, rotate and set_gripper for perception-conditioned staging, transport, posture adjustment and release. Task Specific Memory stores successful command traces from reference-seed exploration for few-shot re-grounding; Global Memory stores reusable success rules and failure models. The bottom strip shows a rollout alternating sparse VLA invocations with analytic control.

4. The Unified Primitive Interface: Six Analytic Primitives Plus One Learned One

The library $\mathcal{P}$ is the only action interface exposed to the planner. Each primitive is invoked by a single JSON object, executes inside the environment until an internal post-condition is reached, and returns control with a refreshed observation. $\mathcal{P}$ is organized into two manipulation families.

Analytic primitives are deterministic, model-based controllers specified from robot kinematics and requiring no training data. They divide into composite primitives, which take a world-frame spatial goal and run an embedded solver to coordinate multiple degrees of freedom, and atomic primitives, which drive one intrinsic channel — wrist orientation, gripper state, base velocity — to a parametric set-point. The VLA primitive vla_act is a learned policy call mapping a prompt and live cameras to action chunks for local contact-rich behavior. The exploratory reset utility is used only during bootstrapping and is not counted as a manipulation primitive.

Primitive	Kind	Role	LIBERO	RoboCasa365	RoboTwin C2R
move_to	Analytic composite	Move the end-effector to a world-frame Cartesian target using the environment's embedded solver	yes	yes	yes
move_pose	Analytic composite	Move the end-effector while co-varying pose variables such as pitch, for reach-limited configurations	yes	via composition	—
rotate_wrist	Analytic atomic	Apply a wrist-yaw set-point while holding current spatial position	yes	—	yes
rotate_pitch	Analytic atomic	Apply a wrist-pitch set-point while holding current spatial position	yes	yes	—
set_gripper	Analytic atomic	Drive the gripper to an open or closed set-point for a fixed number of steps	yes	yes	yes
release	Analytic atomic	Open the gripper under a release post-condition	yes	yes	yes
vla_act	Learned VLA	Execute the frozen VLA in short bursts for local contact-rich interaction	yes	yes	yes
navigate_to	Analytic composite	Drive the mobile base to a world-frame location for kitchen-scale staging	—	yes	—
move_base	Analytic atomic	Apply an open-loop local base-velocity set-point for fine repositioning	—	yes	—
arm binding	Argument	Bind any primitive to the left arm, right arm, or a bimanual task pattern	—	—	yes

Table 1: primitive vocabulary, merging the paper's Table 1 and Table 8. The same primitive names are used across all benchmarks; differences are expressed only through availability, arm binding and implementation backend, and no new primitive name is introduced unless the embodiment exposes a new degree of freedom.

Several design details matter. move_to's internal backend may be an operational-space servo, a Jacobian-based controller or an IK planner, but the exposed primitive semantics are identical — that is what keeps environment differences behind the interface. move_pose is not exposed directly in RoboCasa365; the same behavior is expressed there as a short composition of rotate_pitch and move_to. RoboTwin C2R adds no new manipulation primitive name at all: every primitive can be bound to the left arm, right arm or a bimanual task pattern through the arm argument, so handover-style tasks are represented as compositions of vla_act, analytic transport and release under dual-arm binding rather than as a separate primitive.

The most important constraint of all: the primitive vocabulary is fixed before evaluation, and the planner cannot invent new primitives at deployment time. This is precisely the opposite of lines like ASPIRE, which let the agent grow its own reusable skill library, and it is what makes the empirical claim interesting — that a small fixed primitive library suffices once the planner learns how to use it.

5. vla_act: Turning the VLA into a Retryable Local Attempt

vla_act is the only learned primitive in the vocabulary. It binds to the frozen VLA used by the current benchmark and executes action chunks conditioned on a prompt and live observations. Across benchmarks it covers grasping, constrained placement, fixture actuation, button pressing, drawer or door manipulation, insertion, and embodiment-specific contact behaviors. The planner supplies a task-conditioned prompt and an early-return predicate $\tau$; the frozen VLA $f_{\theta}$ then emits action chunks $a_{t:t+H}$ until $\tau$ is satisfied or the chunk budget is exhausted:

$$f_{\theta}:\ (\text{prompt},\ o_{t})\ \longmapsto\ a_{t:t+H},\qquad \text{repeat until}\ \tau(o_{t+k})=\text{true}\ \text{or}\ k\geq K$$

where $K$ is the max_chunks field of the JSON invocation. $\tau$ may correspond to a lift-and-grasp condition, a contact-state condition, a benchmark predicate, or simply a chunk budget. The same primitive therefore spans grasping, placement, fixture actuation, insertion and bimanual contact, while semantic grounding, spatial re-binding, navigation, re-staging and long-horizon composition stay under planner control.

The paper stresses that the contribution is not merely exposing vla_act but learning when and how to use it. The planner treats VLA execution as a retryable local attempt: stage the robot into a favorable local observation, invoke the VLA, inspect the contact outcome, and re-stage if needed. The VLA is never called as a one-shot black box.

The released code makes the mechanism concrete. On the LIBERO backend, vla_act maps to robots/libero/tools.py::pi0_pick, whose signature lays the stop predicate bare:

def pi0_pick(self, prompt: str, *, max_chunks: int = 24,
             lift_thresh: float = 0.05, gripper_closed_thresh: float = 0.06,
             gripper_open_thresh: float = 0.0, descent_thresh: float = 0.10) -> dict:
    """Closed-loop Pi0.5 pick driven by ``prompt`` as the VLA instruction.
    Success requires the EEF to descend by ``descent_thresh``, then rise by
    ``lift_thresh``, with gripper opening in
    [``gripper_open_thresh``, ``gripper_closed_thresh``). Terminates early
    on LIBERO ``terminated`` (official success) or ``max_chunks``."""
    for c in range(max_chunks):
        self._vlm_chunk(instr)
        chunks_used = c + 1
        z = self._last_obs_eef_z
        ...

Read $\tau$ off that code: success requires the end-effector to descend by descent_thresh, then rise by lift_thresh, with gripper opening inside $[\text{open\_thresh},\ \text{closed\_thresh})$. An inline comment even explains why the ascent peak must be tracked only after the minimum has been observed — a raw |peak - min| also fires at the bottom of the descent, which would be a false lift signal. That is what an early-return predicate actually looks like in production code.

The RoboTwin backend, robots/robotwin/primitives.py::lingbot_act, shows the chunk granularity and the hard budget coupling:

def lingbot_act(self, *, chunks: int = 4, use_length: int = 50,
                prompt: str | None = None) -> dict[str, Any]:
    if int(use_length) != MODEL_SPEC.use_length:
        raise ValueError(f"RoboTwin LingBot requires use_length={MODEL_SPEC.use_length}")
    requested = int(chunks) * MODEL_SPEC.use_length
    for _ in range(int(chunks)):
        status = self.env.last_info["episode_status"]
        budget_exhausted = step_lim is not None and \
            int(status.get("take_action_cnt", 0)) >= int(step_lim)
        if status.get("eval_success") is True or budget_exhausted:
            break
        actions = self.model.infer(observation)[: MODEL_SPEC.use_length]

Chunk length is pinned at $T=50$, the total requested steps are $\text{chunks}\times T$, and either eval_success becoming true or budget exhaustion breaks the loop immediately. That is exactly the paper's statement that primitive-level post-conditions only decide when control returns to the planner. The planner itself has two interchangeable backends — rpent/planner/codex.py::CodexPlanner, built on the OpenAI Codex Python SDK, and rpent/planner/claude_code.py::ClaudeCodePlanner, built on the Claude Agent SDK — sharing the same harness, memory interface, primitive library, frozen-VLA interface and evaluation protocol, differing only in the planner backbone. That is what licenses reporting Codex and CC as two rows over identical machinery.

6. The File-Mediated REPL and Perception Isolation

The harness implements the execution loop as a synchronous file-mediated Read-Eval-Print Loop. A long-running environment worker owns the live simulator state; the planner interacts with it only through serialized primitive invocations and persisted observations. The planner has no access to privileged simulator state, object poses or controller internals.

At turn $t$ the planner reads $o_t$, the task language $\ell$, and retrieved memory context, then emits one invocation $c_t\in\mathcal{P}$ by writing a JSON object to command.json, with the primitive name in the action field and the corresponding keyword arguments alongside. The worker consumes the file, executes the primitive in the live environment, and writes the next indexed observation $o_{t+1}$ together with lightweight execution records. The planner waits for those files before selecting the next primitive. The index NN increases monotonically; the initial observation is written at NN=00.

File or artifact	Role
command.json	Planner-issued primitive invocation $c_t$
state_NN.json	Step-indexed task language, robot proprioception, and benchmark success signal
RGB-D / world-map files	Benchmark-specific perceptual evidence for semantic identification and metric re-grounding
log_NN.json	Diagnostic record: accepted command, primitive status, step counts, and failure information when available
done_NN.flag or terminal file	Synchronization signal indicating the worker finished the current primitive
Task Specific Memory trace	Append-only JSONL procedural memory for one task; each line is one primitive command
Task Specific Memory summary	JSON semantic memory summarizing outcome, strategy, recovery decisions and failure modes
Global Memory	Cross-task success rules and failure models for using the primitive library

Table 2: files used by the file-mediated REPL (paper Table 7). These records make the rollout auditable without exposing oracle object coordinates to the planner.

Perception isolation is written into the prompt as an operating procedure. The agent receives object names and proprioception from the state file but never object coordinates; it must localize entities by picking pixels in RGB images and indexing the corresponding precomputed world map. The procedure further requires sampling multiple stable pixels on the visible surface of an entity and using a robust statistic, typically the median, while avoiding rims, object edges, table gaps, holes, reflections and background pixels, and re-localizing whenever the robot, camera, object, base, fixture or grasp state changes. The paired execution contract is: write one JSON command, wait for the driver to finish that primitive, read the new state, log, images, depth maps and world maps, then decide the next command from the new evidence. Every primitive call is treated as an experiment whose result must be observed before the next command is issued — which is precisely what makes retry viable.

7. Two Memory Modules: Procedural Trace and Cross-Task Rules

This is the sharpest point of departure from the code-as-policies literature. The related-work section names two recurring deficiencies in that line. First, task-specific execution traces are rarely represented as reusable, parameterized memory that can be grounded again under new spatial layouts. Second, failure knowledge is seldom distilled into a Global Memory that prevents the planner from repeating known empty grasps, false successes or unstable staging choices. Voyager showed that persistent memory improves embodied agents in a digital sandbox, but that memory-centric design had not been combined with a VLA-backed contact-rich primitive for physical manipulation. This paper couples the two.

Task Specific Memory stores the reusable structure of a solved task instance as a procedural JSONL trace plus a semantic JSON summary. The trace records which primitive invocations were issued; the summary records why the strategy worked and what should be avoided. The paper's simplified summary reads:

{"task": "put the black bowl on the wooden tray",
 "success": true,
 "trace_file": "task_specific_memory_put_black_bowl_on_tray_s0.jsonl",
 "strategy": "use VLA for grasping, then analytic transport and release",
 "avoid": ["do not reuse reference xyz values",
           "verify placement with the benchmark success signal"]}

The paired procedural trace stores the primitive order:

{"action": "vla_act", "prompt": "grasp the black bowl", "max_chunks": 2}
{"action": "move_to", "xyz": [0.12, -0.08, 0.92], "gripper": null}
{"action": "release"}

The most commonly misread point: the trace is a task-level solution skeleton, not an open-loop trajectory. It records the ordering of analytic and VLA-backed primitives, the placement of VLA invocations, and the transition points between contact-rich execution, transport, release and verification. Spatial arguments in the stored trace are treated as reference-scene bindings; at deployment the planner reuses the memory structure but re-grounds objects, fixtures, support surfaces and target poses from the current observation. The avoid-rule "do not reuse reference xyz values" exists exactly to stop coordinate replay.

Global Memory stores task-independent operating knowledge about the primitive library, in two entry classes. A success rule: use VLA primitives for contact-rich phases such as irregular grasping or fixture interaction, and after a stable grasp prefer analytic motion for long transport and precise placement. Failure models: if the gripper closes but the object does not move with the end-effector, treat the attempt as an empty grasp, re-localize the object and re-stage before retrying; and do not terminate from visual proximity alone — check the benchmark success signal and the latest execution record.

Memory is constructed during interaction rather than written only after the rollout. After each primitive the planner reads the new observation and diagnostic record and classifies the outcome as progress, recoverable failure, or unrecoverable failure. Successful rollouts are stored as Task Specific Memory. Recoverable failures remain in the trace and are explained in the semantic summary so that subsequent steps document the correction. Failed attempts are retained as negative evidence and may contribute failure models to Global Memory. Across attempts memory is refined rather than merely accumulated: a later attempt can replace the procedural trace if it yields a shorter or more reliable solution, while earlier failure observations persist as constraints on future planning.

In the codebase this lands in rpent/memory/manager.py: SCOPES = {"global", "suite"} defines the two scopes, _split_frontmatter() requires every memory leaf to carry YAML frontmatter with a valid scope field, and MemoryManager handles leaf writes, old-versus-new metadata comparison on conflict, and index generation from frontmatter. Global Memory is the global scope; Task Specific Memory hangs under suite.

flowchart TD
    A["Task language l
RGB-D o_t
proprio q_t"] --> B["Agentic planner Pi"]
    M1["Task Specific Memory
JSONL trace + JSON audit"] --> B
    M2["Global Memory
success rules + failure models"] --> B
    B --> C{"primitive class of c_t in P"}
    C -->|"analytic composite"| D["move_to / move_pose
navigate_to"]
    C -->|"analytic atomic"| E["rotate_wrist / rotate_pitch
set_gripper / release / move_base"]
    C -->|"contact-rich"| F["vla_act
frozen VLA f_theta
action chunks until tau or K"]
    D --> G["environment worker"]
    E --> G
    F --> G
    G --> H["observe artifacts
state_NN.json + log_NN.json
RGB-D + world map + done_NN.flag"]
    H -->|"progress"| B
    H -->|"empty grasp or false success"| I["re-stage with analytic primitives
then retry"]
    I --> B
    H -->|"predicate G satisfied"| J["write memory
parameterized trace + rules"]

Figure 3: the actual Harness VLA execution loop. The planner emits only JSON calls over a fixed primitive library; analytic primitives carry grounding, staging, transport, posture and release, while vla_act is invoked only in contact-rich phases. After every primitive return the agent observes and diagnoses; failures are re-staged and retried according to Global Memory failure models, and successful rollouts are written back as parameterized traces plus rules.

8. Experimental Setup and Evaluation Protocols

Evaluation spans four benchmark families: the tabletop suites LIBERO and LIBERO-Pro, and the household and bimanual suites RoboCasa365 and RoboTwin C2R. Throughout, the planner operates over the same frozen primitive vocabulary $\mathcal{P}$ and may not introduce new primitives at deployment time. The VLA primitive is instantiated with benchmark-specific frozen policies behind a unified vla_act interface: the RLinf-released pi05_libero130_fullshot $\pi_{0.5}$-SFT checkpoint, denoted $\pi_{\mathrm{RLinf}}$, for LIBERO and LIBERO-Pro; the frozen RLDX-1 RoboCasa checkpoint for RoboCasa365; and the authors' post-trained LingBot-VLA checkpoint for RoboTwin C2R.

Benchmark	Tasks	Trials/task	Reported rollouts	Protocol
LIBERO	40	10	400	Seed $s_0$ used only to build memory; evaluation on held-out seeds $s_1$–$s_{10}$
LIBERO-Pro	80	10	800	8 cells (4 task families × T/S perturbations), same few-shot protocol
RoboCasa365	50	10 / 5 / 5	340	Atomic-Seen 18×10, Composite-Seen 16×5, Composite-Unseen 16×5
RoboTwin C2R	50	5	250	Zero-shot clean-to-randomized: trace from demo_clean, evaluated directly in demo_randomized

Table 3: evaluation protocol summary (paper Tables 9–13). In LIBERO-Pro, T denotes instruction redirection and S denotes position swap. In RoboCasa365, seen/unseen refers to whether the task template appears in the pretraining set, not whether the exact episode, trajectory or scene was observed.

The RoboTwin C2R protocol is the strictest of the four. For each task the Task Specific Memory trace is obtained from one official scripted-expert-verified seed in the demo_clean setting, and evaluation then runs directly in the official demo_randomized setting on five scripted-expert-verified randomized seeds, with no additional trace search, fine-tuning or task-level adaptation in the randomized setting. Expert verification only ensures that sampled task instances are feasible under the official task definition; it is independent of the method and does not use Harness VLA rollouts for seed selection.

9. Main Results: The Gain Grows With the Perturbation

Standard LIBERO. Harness VLA (CC) reaches an aggregate 96.0% (384/400), including 100.0% on Object and 93.0% on LIBERO-10. Against the same frozen $\pi_{\mathrm{RLinf}}$ checkpoint used inside vla_act, evaluated directly at 95.3%, the harness preserves competitive standard-suite performance while exposing that identical policy through a controllable primitive interface for the perturbed evaluations that follow.

Method	Spatial	Object	Goal	LIBERO-10	Overall
OpenVLA	84.7	88.4	79.2	53.7	76.5
NORA	85.6	89.4	80.0	63.0	79.5
$\pi_0$	96.8	98.8	95.8	85.2	94.2
$\pi_{\mathrm{RLinf}}$ (frozen, direct)	99.0	96.0	97.0	89.0	95.3
AtomVLA	96.4	99.6	97.6	94.4	97.0
Harness VLA (CC)	97.0	100.0	94.0	93.0	96.0

Table 4: standard LIBERO success rates (%, paper Table 2). $\pi_{\mathrm{RLinf}}$ and Harness VLA (CC) are both evaluated by the authors on 100 trials per suite (10 tasks × 10 seeds), and both use the same RLinf-released $\pi_{0.5}$-SFT checkpoint inside vla_act.

LIBERO-Pro. This is the headline. Existing end-to-end VLAs collapse under both distribution shifts: OpenVLA and NORA score 0.0 across all eight cells, $\pi_0$ totals 0.3, $\pi_{0.5}$ 11.0, MolmoAct 1.5, X-VLA 3.8, AtomVLA 6.3. RATS is the strongest reported prior baseline at 43.8% over the six cells it reports. Harness VLA reaches 72.1% with Codex and 82.4% with CC, improving over RATS by 38.6 points in the headline comparison. The direct $\pi_{\mathrm{RLinf}}$ baseline reaches 50.0% under the same protocol, so the gain does not simply come from the frozen VLA backbone — the harness itself contributes 32.4 points on top of it.

Method	Spat-T	Spat-S	Obj-T	Obj-S	Goal-T	Goal-S	L10-T	L10-S	Overall
OpenVLA	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0
$\pi_0$	0.0	0.0	0.0	2.0	0.0	0.0	0.0	0.0	0.3
$\pi_{0.5}$	1.0	20.0	1.0	17.0	2.0	38.0	1.0	8.0	11.0
MolmoAct	0.0	0.0	0.0	6.0	0.0	0.0	6.0	0.0	1.5
X-VLA	0.0	0.0	8.0	2.0	9.0	1.0	10.0	0.0	3.8
AtomVLA	1.0	16.0	0.0	10.0	11.0	2.0	9.0	1.0	6.3
Cap-X	14.0	12.0	18.0	22.0	17.0	26.0	/	/	18.2
RATS	31.0	29.0	63.0	61.0	36.0	43.0	/	/	43.8
$\pi_{\mathrm{RLinf}}$ (frozen, direct)	42.0	59.0	71.0	78.0	45.0	42.0	49.0	14.0	50.0
Harness VLA (Codex)	81.0	69.0	94.0	91.0	75.0	66.0	52.0	49.0	72.1
Harness VLA (CC)	94.0	80.0	88.0	90.0	87.0	87.0	71.0	62.0	82.4

Table 5: LIBERO-Pro success rates (%, paper Table 3). Each cell aggregates 100 trials (10 tasks × 10 seeds); "/" marks an unavailable or unreported cell. Cap-X and RATS report only the six non-LIBERO-10 cells, so their overall values average over reported cells only. T = instruction redirection, S = position swap.

The per-cell lift from $\pi_{\mathrm{RLinf}}$ to Harness VLA (CC) is far from uniform: Goal-S goes 42.0 to 87.0 (+45.0), L10-S goes 14.0 to 62.0 (+48.0), Spatial-T goes 42.0 to 94.0 (+52.0), while Obj-S moves only 78.0 to 90.0 (+12.0). The pattern is legible — the harder the frozen VLA falls, the more the harness restores. Obj-S is already the checkpoint's best cell and offers little headroom, whereas long-horizon composition (L10-S) and goal re-binding under layout change (Goal-S) are exactly where a monolithic policy breaks down.

RoboCasa365. Here the evaluation moves from tabletop manipulation to household kitchen tasks with mobile staging, articulated fixtures and longer composite routines. RLDX-1 evaluated directly reaches 30.0% overall; Harness VLA reaches 57.1% with Codex and 48.6% with CC, so the Codex instantiation improves over RLDX-1 by 27.1 points. By split, Atomic-Seen rises from 60.0 to 92.0, Composite-Seen from 21.3 to 61.0, and Composite-Unseen from 5.0 to 13.8. Composite tasks are the main source of the gain, consistent with the intended decomposition: the planner handles navigation, staging and re-staging after local failures while the frozen VLA remains the local contact-rich primitive.

Method	Atomic-Seen	Composite-Seen	Composite-Unseen	Overall
$\pi_0$	34.6	6.1	1.1	14.8
$\pi_{0.5}$	39.6	7.1	1.2	16.9
RLDX-1 (frozen, direct)	60.0	21.3	5.0	30.0
WorldDreamer	66.3	26.7	9.0	35.3
Harness VLA (CC)	79.4	47.5	15.0	48.6
Harness VLA (Codex)	92.0	61.0	13.8	57.1

Table 6: RoboCasa365 success rates (%, paper Table 4). Harness VLA uses one reference seed only for bootstrapping; reported evaluation uses ten held-out seeds for Atomic-Seen and five held-out seeds for each composite split.

RoboTwin C2R. On zero-shot clean-to-randomized transfer, direct LingBot-VLA reaches 50.4%, and Harness VLA raises the same frozen backend to 58.0% with Codex and 58.4% with CC. External context rows are GR00T-N1.7 at 20.7%, $\pi_{0.5}$ at 47.9% and StarVLA at 10.6%. The absolute gain here (+8.0 points) is much smaller than on LIBERO-Pro, and the reason is structural: bimanual handover-style tasks end inside a contact-rich phase, leaving less of the episode for analytic primitives to take over. The completion-attribution data below confirms this directly.

10. The Zero-Shot Control: What Memory Actually Buys

To separate online planner reasoning from bootstrapped harness memory, LIBERO-Pro Goal is also evaluated in a strict zero-shot setting where the agent retrieves neither the target-setting Task Specific Memory nor the corresponding Global Memory.

Setting	Method	T0	T1	T2	T3	T4	T5	T6	T7	T8	T9	Avg
Pos (S)	Cap-X	0.0	4.0	0.0	36.0	22.0	60.0	4.0	2.0	62.0	66.0	25.6
Pos (S)	Harness VLA (CC) zero-shot	0.0	10.0	0.0	20.0	90.0	0.0	10.0	80.0	100.0	0.0	31.0
Task (T)	Cap-X	0.0	0.0	10.0	38.0	12.0	4.0	34.0	12.0	40.0	18.0	16.8
Task (T)	Harness VLA (CC) zero-shot	10.0	100.0	90.0	100.0	20.0	80.0	90.0	100.0	100.0	100.0	79.0

Table 7: per-task success rates on LIBERO-Pro Goal (%, paper Table 5). Zero-shot Harness VLA (CC) retrieves no Task Specific Memory and runs 10 seeds per task; Pos = position swap (S), Task = instruction redirection (T).

Comparing against the few-shot Goal cells in Table 5 quantifies the memory contribution cleanly. Without memory the planner retains much of its semantic re-binding ability under instruction redirection: Goal-T is 79.0% zero-shot versus 87.0% few-shot, a gap of only 8 points. Under position swap it drops substantially: Goal-S is 31.0% zero-shot versus 87.0% few-shot, a gap of 56 points.

That asymmetry is the single most informative number in the paper. Semantic re-grounding is carried mostly by the planner's online multimodal reasoning and needs no task-specific memory to work. Spatially perturbed manipulation, by contrast, depends heavily on the task-specific primitive organization discovered during exploration — analytic primitives supplying localization, staging, transport and release around the contact-rich phase, with vla_act invoked at learned interaction points and re-stageable after failures. Per-task, the zero-shot Pos(S) variance is extreme: Task 8 hits 100.0 while Tasks 1, 2, 5 and 9 sit at 0.0. That all-or-nothing distribution is the signature of a missing stable staging skeleton.

11. Three Mechanism Findings

Finding 1: planner-level semantic re-grounding restores task-conditioned behavior. The large gap in Table 5 is achieved without altering the visuomotor backbone. $\pi_{\mathrm{RLinf}}$ already solves the standard variants of these tasks, but its behavior is weakly conditioned on the task description and current scene binding. Harness VLA makes semantic grounding explicit at the planner level: the planner parses the task description, resolves the current contact target from live RGB-D observation, uses analytic primitives for staging and repositioning, and invokes or re-invokes vla_act only for the local contact-rich phase. Semantic and scene-level reasoning belongs to the planner; the frozen VLA executes the contact-rich operation under the planner-provided binding.

Figure 4 (paper Figure 3, first triplet, frame 1): $\pi_{\mathrm{RLinf}}$ on the standard Object task, where the task is completed correctly.

Figure 5 (paper Figure 3, first triplet, frame 2): the same $\pi_{\mathrm{RLinf}}$ on the task-perturbed Object-Pro variant. The visual scene is similar to the previous frame while the instruction has redirected the target, yet the policy repeats the standard behavior instead of following the new description.

Figure 6 (paper Figure 3, first triplet, frame 3): Harness VLA on the same perturbed task. The planner re-parses the instruction, re-binds the target, uses analytic primitives for staging, and calls vla_act only for the local contact-rich operation.

Figure 7 (paper Figure 3, second triplet, frame 3): Harness VLA on a swap-perturbed Goal-Pro task. In the same triplet, $\pi_{\mathrm{RLinf}}$ blindly moves the object toward the training-time region after the layout changes, whereas Harness VLA re-grounds the target through the agentic planner.

Finding 2: planner-staged VLA invocation improves frozen-policy reliability. The mechanism has two halves. First, staging restores a VLA-compatible local state: under deployment perturbations such as semantic retargeting and spatial-layout shifts, the original VLA viewpoint or pre-contact pose may no longer expose the correct contact target in a familiar configuration. By re-staging the robot around the current scene, the planner brings the target back into a VLA-compatible local observation while preserving the correct semantic binding. This is why the harness can improve a frozen VLA without changing its parameters — it learns where the VLA should begin acting rather than asking the policy to absorb the full distribution shift by itself. Second, retry localizes contact failures: VLA execution is stochastic and short-horizon contact is physically brittle, so a single failed attempt need not terminate the episode. The planner observes an incomplete or unstable outcome, re-stages the robot, and re-invokes vla_act, instead of letting a transient failure propagate through a monolithic long-horizon policy. Repeated VLA calls are therefore not continuous low-level control; they are sparse, planner-selected attempts that make contact-rich execution recoverable.

Figure 8 (paper Figure 4a): on LIBERO-Pro, cumulative task success as a function of the maximum number of VLA primitive invocations allowed per episode. The blue dashed line marks the corresponding frozen-policy baseline; the gray dashed line marks full Harness VLA performance with all planner-selected invocations.

Figure 9 (paper Figure 4b): the same analysis on RoboCasa365, where the curve keeps climbing over more invocations, reflecting mobile staging and longer composite routines that need more retries.

Figure 10 (paper Figure 4c): the same analysis on RoboTwin C2R. Across all three benchmarks success rises rapidly after the first few VLA calls and then saturates toward the full harness result — repeated planner-staged invocation is useful, but remains sparse.

Finding 3: analytic primitives isolate non-contact execution from contact-rich control. Analytic primitives do not replace the VLA on contact-rich operations. They handle the surrounding non-contact structure of the task: free-space transport, pre-contact staging, wrist or base reorientation, retreat, and post-contact repositioning. This lets the planner reserve vla_act for the local contact-rich phases that genuinely need learned visuomotor control, including grasping, constrained placement, button pressing, faucet turning, drawer manipulation and coffee-machine operation. Once stable contact has been established, the planner can move, rotate or navigate the robot toward the next relevant region analytically, invoking the VLA again when the next contact-rich phase begins. The analytic vocabulary therefore does not solve contact-rich manipulation by itself; it expands the conditions under which the same frozen VLA can be reused.

Figure 11 (paper Figure 6): task completion attribution across benchmarks. Bars show the fraction of successful rollouts whose final benchmark completion predicate fires after an analytic primitive (blue) or after a VLA primitive (orange). LIBERO-Pro family tasks are mostly finished by analytic primitives after the VLA has established stable contact, whereas RoboCasa365 and RoboTwin C2R contain more terminal contact-rich operations such as fixture actuation, constrained placement, or bimanual object interaction.

This attribution chart explains the differences in gain magnitude across the three benchmarks. LIBERO-Pro success rollouts usually end with analytic transport, release or repositioning once contact is established, so the analytic vocabulary has the most to take over and the harness gain is largest. In RoboCasa365 and RoboTwin C2R the final predicate often depends directly on a contact-rich operation, so successful rollouts more frequently finish inside the VLA primitive and the share that can be handed to analytic control is naturally smaller. That is the mechanistic account of why RoboTwin delivers +8.0 points while LIBERO-Pro delivers +38.6.

12. Primitive Usage Statistics: the VLA Is a Minority of Calls

Appendix F reports the canonical primitive calls issued by Harness VLA (CC) across all three environments: backend-specific VLA calls are merged into the unified vla_act, implementation-level motion macros are folded into the analytic primitive they expose, and non-manipulation helpers such as rendering, reset, notes and no-ops are excluded. Percentages are computed within each environment's total manipulation-primitive calls.

Canonical primitive	Kind	LIBERO	RoboTwin C2R	RoboCasa365
move_to	Analytic composite	6263 (61.8%)	685 (40.9%)	3004 (38.7%)
move_pose	Analytic composite	203 (2.0%)	—	—
navigate_to	Analytic composite	—	—	701 (9.0%)
rotate_wrist	Analytic atomic	44 (0.4%)	1 (0.1%)	—
rotate_pitch	Analytic atomic	58 (0.6%)	—	66 (0.8%)
set_gripper	Analytic atomic	1137 (11.2%)	71 (4.2%)	371 (4.8%)
release	Analytic atomic	831 (8.2%)	124 (7.4%)	76 (1.0%)
move_base	Analytic atomic	—	—	808 (10.4%)
vla_act	VLA	1598 (15.8%)	794 (47.4%)	2746 (35.3%)
Total		10134	1675	7772
Analytic primitives, class total	Class	8536 (84.2%)	881 (52.6%)	5026 (64.7%)

Table 8: canonical primitive usage across benchmark environments (paper Tables 18 and 19). Each cell reports the count and percentage of manipulation-primitive calls within that environment; a dash means the primitive is not exposed there.

Writing the VLA share as $\rho_{\text{vla}}$ makes the contrast explicit:

$$\rho_{\text{vla}}=\frac{N_{\texttt{vla\_act}}}{N_{\text{total}}}:\quad \frac{1598}{10134}=15.8\%\ (\text{LIBERO}),\quad \frac{794}{1675}=47.4\%\ (\text{RoboTwin}),\quad \frac{2746}{7772}=35.3\%\ (\text{RoboCasa})$$

The usage pattern supports the intended asymmetric decomposition. In LIBERO, analytic primitives dominate: move_to alone accounts for 61.8% of calls while vla_act accounts for 15.8%. That matches the tabletop structure of the tasks — the VLA is used mainly to establish contact-rich grasps or fixture interactions, after which analytic transport, gripper control and release complete much of the rollout. RoboCasa365 shifts the mix toward mobile staging and longer-horizon interaction: navigate_to and move_base together account for 19.4% of calls, while vla_act rises to 35.3% because kitchen tasks require learned grasps, fixture actuation and constrained placements across larger scenes. RoboTwin C2R has the highest VLA share at 47.4%, reflecting bimanual grasping and handover-like contact, yet analytic primitives still provide a slight majority of calls (52.6%) for planned arm motion, release and final arrangement.

Across all three embodiments the frozen VLA is not used as a monolithic end-to-end controller; it is invoked as a contact-rich primitive inside a larger analytic scaffold. The exact ratio changes with embodiment and task family, but the qualitative division is stable: analytic primitives handle reproducible geometry and staging, while vla_act supplies the learned local interactions that are difficult to script.

13. The Three VLA Backends and the Unified Abstraction

$\pi_{\mathrm{RLinf}}$ follows the $\pi_{0.5}$ vision-language-action architecture, encoding visual observations $I_t$, language instructions $\ell$ and robot state $q_t$ into a unified transformer representation, initialized from a pretrained vision-language backbone and aligned to robot action spaces via supervised learning. Consistent with $\pi_{0.5}$, it supports hierarchical inference in which high-level semantic subtask prediction and low-level action generation are jointly modeled in one policy: given an observation and instruction the model first predicts a high-level subtask $\hat{\ell}$ such as "pick up the plate", which then conditions low-level action generation producing continuous action chunks $a_{t:t+H}$ via FAST tokenization or flow-based continuous modeling. It is supervised-fine-tuned on the LIBERO-130 dataset following the $\pi_{0.5}$ protocol; no additional training or adaptation is performed here and the model is fully frozen. Directly evaluated it reaches 95.3% on standard LIBERO and drops to 50.0% on LIBERO-Pro.

RLDX-1 adopts a Multi-Stream Action Transformer (MSAT) as its core action-modeling architecture. The system first encodes multi-frame video observations and language instructions with a VLM based on Qwen3-VL 8B and extracts action-relevant representations via cognition tokens; a memory module aggregates historical cognition features into history-aware representations. The action model builds on MSAT, decoupling cognition and action streams and optionally introducing a physics stream when physical signals are available, with the streams jointly modeled through cross-stream self-attention. Training uses a flow-matching diffusion transformer for continuous action prediction, learning a velocity field that maps noisy action trajectories to clean action sequences and generating future actions by iterative denoising; at inference the model produces action chunks and executes partial chunks sequentially for stable closed-loop control. Directly evaluated on RoboCasa365 it reaches 60.0% on Atomic-Seen, 21.3% on Composite-Seen and 5.0% on Composite-Unseen, for a 30.0% weighted overall.

LingBot-VLA is built on a pretrained Qwen2.5-VL backbone extended with a Mixture-of-Transformers (MoT) architecture that separates vision-language reasoning and action generation into dedicated transformer pathways, coupled through shared self-attention so that multimodal sequence modeling stays unified while cross-modal interference is mitigated; an action-expert module predicts continuous control signals conditioned on multimodal embeddings. Action modeling uses a flow-matching formulation for continuous prediction together with chunked action decoding, where a fixed-length action sequence is predicted autoregressively in a single forward pass with chunk size $T=50$. The model is pretrained on large-scale real-world dual-arm teleoperation data collected across 9 robotic embodiments, then adapted by supervised fine-tuning on RoboTwin manipulation trajectories; after post-training the checkpoint is frozen for both the direct VLA baseline and all Harness VLA evaluations.

Post-training configuration	Value
Optimizer / learning rate	AdamW / $1\times 10^{-4}$ (vision encoder $1\times 10^{-6}$)
Weight decay / loss	0 / L1 Flow Matching (L1_FM)
Chunk size / max sequence length	$T=50$ / 2048
Flow steps / max action and state dim	10 / 75 / 75
Global batch size / image resolution	256 / $224\times 224$
Camera views	top + wrist left + wrist right
Precision / distributed	mixed precision (bf16/fp32) / FSDP2

Table 9: post-training configuration of LingBot-VLA on RoboTwin (paper Table 14). These parameters correspond to the configuration used for all LingBot-VLA post-training experiments reported in the work.

The unified abstraction is what makes the whole design portable across benchmarks: heterogeneous VLA models are abstracted as interchangeable contact-rich execution primitives, the LLM planner owns semantic grounding, spatial decomposition and long-horizon task planning, and each VLA is invoked solely for localized interaction execution conditioned on the current observation. Switching benchmark means switching the vla_act backend; the harness, memory interface, primitive names and evaluation protocol stay put.

14. Limitations

First (author-stated): the feedback loop between the high-level planner and the low-level VLA is open. What vla_act returns to the planner is a primitive status and a diagnostic record, not a differentiable or structured contact signal, so the planner can only judge whether a contact succeeded by re-observing the scene. Failure detection therefore rests on after-the-fact visual and proprioceptive reading. The Global Memory rule "if the gripper closes but the object does not move with the end-effector, treat it as an empty grasp" is essentially a patch over that openness rather than a genuine closed-loop feedback channel.

Second (author-stated): no joint fine-tuning via environmental rewards or human preferences. Keeping the VLA frozen makes the "extend without touching parameters" claim clean, but it also means none of the scheduling knowledge the harness acquires ever flows back into the policy weights. The authors note this calls for future sample-efficient reinforcement learning, e.g. GRPO.

Third (author-stated): the absence of fine-grained image captioning constrains structural reasoning in highly cluttered, long-horizon tasks. The perception channel is currently "pick pixels in RGB, index the precomputed world map, take the median". That metric grounding is adequate when objects are sparse, but under heavy occlusion and cluttered stacking there is no fine-grained semantic description to lean on.

Fourth (mine): every evaluation is in simulation. All four benchmark families — LIBERO, LIBERO-Pro, RoboCasa365, RoboTwin C2R — are MuJoCo/Robosuite-based simulated environments, and the paper reports no real-robot results. Both core harness mechanisms depend on properties that simulation gives for free: the synchronization assumption of the file-mediated REPL (once done_NN.flag appears, a consistent state_NN.json is readable), and the reachability guarantee behind analytic primitives' "world-frame Cartesian target plus embedded solver". On real hardware both face sensing latency, calibration error and solver failures, and retry counts plus episode duration would inflate accordingly. LIBERO rollouts already average about $10134/400\approx 25$ primitive calls per episode; whether that cost is acceptable on a physical robot is not answered.

Fifth (mine): bootstrapping cost is not charged against the baselines. Every task first consumes a seed-$0$ exploration round to build Task Specific Memory, run under what the paper calls a generous wall-clock budget with unlimited reset. Baselines have no such phase. The zero-shot RoboTwin protocol and the zero-shot LIBERO-Pro Goal control partly address this concern — the latter shows that the 31.0-to-87.0 gap on Goal-S is exactly what bootstrapped memory contributes — but the cost of the bootstrapping phase itself (attempts per task, wall-clock time, number of resets) is never quantified.

Sixth (mine): the Codex-versus-CC ordering flips across benchmarks, so results remain sensitive to the planner backbone. On LIBERO-Pro, CC (82.4) clearly beats Codex (72.1); on RoboCasa365, Codex (57.1) beats CC (48.6); on RoboTwin C2R they are effectively tied (58.0 / 58.4). The mechanism analyses uniformly use CC as the representative instantiation on the grounds that both share the same harness and protocol and differ only in backbone. But a ten-point-scale difference between backbones means "which LLM serves as the planner" is still a per-benchmark practical decision rather than a solved engineering detail.

15. Conclusion and Outlook

Harness VLA is an asymmetric hierarchical framework that casts a frozen VLA as a single contact-rich primitive interface inside an LLM-driven agent, delegating transport, posture, navigation and release phases to the planner. From the standpoint of agent harness engineering its conclusion is that reliable manipulation can come not only from training a stronger policy, but also from surrounding a frozen policy with an auditable execution loop, fixed primitive contracts, memory, feedback and task-level verification. Evaluations across standard and heavily perturbed benchmarks support the sharper claim: pretrained VLAs are most effective when isolated to contact-rich visuomotor control, and abstracting semantic and spatial bindings away from the VLA prevents the catastrophic failures frequently observed in monolithic deployments.

Read in layers, the numbers hold up. The headline +38.6 and +27.1 points are relative to the strongest reported baselines. Relative to direct evaluation of the same frozen backend, the figures are LIBERO-Pro 50.0 to 82.4 (+32.4), RoboCasa365 30.0 to 57.1 (+27.1), and RoboTwin C2R 50.4 to 58.4 (+8.0). The second comparison is the stricter and more credible one, since it subtracts out the VLA backbone's own capability entirely. And the near-parity on standard LIBERO, 95.3 to 96.0, shows that robustness here is not bought by sacrificing in-distribution performance.

The complementary future direction the authors name is to combine fixed-vocabulary composition with automatic skill-discovery systems such as ASPIRE: when repeated primitive compositions reveal a missing abstraction, an agent could propose, validate and admit a new reusable skill while retaining the auditable primitive interface and the VLA-backed contact specialization studied here. If that works, the disagreement between fixed-vocabulary and growing-vocabulary approaches becomes a continuum, with the harness deciding when a new primitive deserves to exist rather than letting the skill library expand without constraint.

Golden Lines

"Rather than expanding the skill library, the harness learns the operating range of these fixed primitives."

"It learns where the VLA should begin acting, rather than asking the policy to absorb the full distribution shift by itself."