# Does ValueFormer Finally Solve VLA's Silent Failure Problem?

A new paper from Inkyu Sa, Konstantin Stulov, and Rajat Bhageria answers one of the most practically painful questions in [Vision-Language-Action model](https://humanoidintel.ai/glossary/vision-language-action-model) deployment: how do you know when a rollout is failing before it's too late? Their answer — ValueFormer, a compact causal transformer critic sitting atop a frozen DINOv3 backbone — lifted task completion on a real-robot bimanual sandwich-assembly benchmark from 70% to 85% across 1,427 episodes, while cutting live serving cost 3–5× through batched bf16 encoding. The critic runs at 2 Hz on a single GPU alongside the policy, making it deployable on hardware that teams are already running today.

The core insight is architectural but the real contribution is the labeling scheme. VLA policies trained by [imitation learning](https://humanoidintel.ai/glossary/imitation-learning) (behavior cloning specifically) produce action streams that look nearly identical whether a task is succeeding or about to collapse — the policy has no internal notion of progress. ValueFormer provides that notion without requiring reinforcement learning or a simulator, both of which are impractical for tasks involving deformable objects like food.

---

## The Labeling Problem Is Harder Than the Architecture

The paper's central argument is blunt: the per-frame label, not the transformer architecture, is the hard part. A terminal success/failure bit is technically learnable but far too sparse — it tells you *that* a rollout failed, not *when* it went wrong or whether intermediate recoveries carry signal.

ValueFormer's solution involves two design choices that pull in opposite directions by design:

**V_mc (smooth Monte Carlo value):** A continuous, dense signal shaped for advantage estimation — useful for weighting training examples.

**Sharp binary value:** A high-precision signal for online mistake detection during live rollouts.

Running both from a single forward pass is the efficiency lever. You don't pay twice.

The labeling strategy for failed episodes uses what the authors call a *stage-aware, success-then-decay return*: the success curve is preserved up to the failure stage, then decays afterward. Critically, mistake detection is supervised from *mistake intervals* rather than a single failure timestamp, meaning episodes where the policy recovers mid-task still contribute gradient. That's a meaningful departure from how most critic training in robotics handles partial success.

---

## Real-Robot Results on Bimanual Sandwich Assembly

The benchmark is a real-robot bimanual sandwich-assembly task evaluated across 1,427 episodes — a dataset large enough to draw statistically meaningful conclusions, though the authors appropriately note the 70% → 85% improvement is "within noise at n=20" for individual evaluation runs. That's the kind of honest qualification that should be standard but rarely is.

The serving efficiency result is arguably as important as the accuracy number for practical deployment. A 3–5× reduction in live inference cost via batched bf16 encoding means the critic is not a compute luxury — it's something teams can run on the same GPU already driving their policy. At 2 Hz, it's fast enough to flag rollout degradation before a manipulator has committed to an irrecoverable state.

[Dexterous manipulation](https://humanoidintel.ai/glossary/dexterous-manipulation) of deformable objects like sandwiches is explicitly resistant to [sim-to-real transfer](https://humanoidintel.ai/glossary/sim-to-real-transfer) — you cannot simulate bread deformation with sufficient fidelity to train a useful critic in-sim. That's precisely why the real-robot-first approach here matters. The entire ValueFormer pipeline is designed around the constraint that synthetic data is unavailable.

---

## Why This Matters for the Broader VLA Deployment Stack

The field is converging on VLA as the dominant policy architecture for dexterous humanoid tasks. Labs including Physical Intelligence and teams building on foundation models from Nvidia GR00T are all grappling with the same silent-failure problem that ValueFormer targets. Behavior cloning at scale produces capable average-case policies, but average-case performance is insufficient for semi-autonomous deployment where a human supervisor needs to know *when* to intervene — not just *whether* the task eventually succeeded.

ValueFormer's semi-autonomous framing is the honest positioning. The critic doesn't fix bad policies; it makes bad-policy moments detectable so humans or supervisors can intervene. That's a more deployable short-term story than full autonomy, and it maps directly to how industrial customers are actually thinking about humanoid robot deployment in 2026 — human-in-the-loop for exception handling, not full lights-out operation.

The policy-agnostic design is also significant. Because ValueFormer sits on a frozen DINOv3 backbone and doesn't require access to policy internals, it can in principle be layered onto existing trained VLAs without retraining from scratch. That dramatically lowers the integration cost for teams that have already invested heavily in their policy training pipelines.

---

## Skeptical Read

A few caveats deserve attention before this gets treated as a solved problem.

First, the 70%→85% lift is demonstrated on a single task — bimanual sandwich assembly. Generalization to other manipulation domains, or to mobile bimanual platforms on humanoid embodiments, is unvalidated by this paper. The authors don't claim otherwise, but the robotics community has a consistent pattern of over-indexing on single-task benchmark results.

Second, the "policy-agnostic" claim is partially architectural. Whether ValueFormer's labeling scheme transfers cleanly to tasks with different failure mode distributions (e.g., manipulation tasks where failure is gradual rather than stage-discrete) is an open question.

Third, 2 Hz critic inference is sufficient for sandwich assembly timescales. For faster-paced manipulation tasks — think high-speed pick-and-place or dynamic whole-body control — the latency budget may not hold.

None of these are criticisms of the paper's contributions, which are real. They're flags for engineering teams evaluating whether to integrate ValueFormer into their deployment stack today.

---

## Key Takeaways

- **ValueFormer is a compact causal transformer critic** that adds dense per-frame value signals to VLA policies without requiring RL or simulation.
- **Task completion lifted from 70% to 85%** on a real-robot bimanual sandwich-assembly benchmark across 1,427 episodes.
- **The labeling scheme — not the architecture — is the core contribution**: stage-aware, success-then-decay returns for failed episodes and mistake-interval supervision enable meaningful gradient from partial recoveries.
- **Two signals from one forward pass**: smooth V_mc for advantage estimation and a sharp binary value for online mistake detection.
- **3–5× inference cost reduction** via batched bf16 encoding enables 2 Hz critic operation on a single GPU alongside the policy.
- **Policy-agnostic design** means ValueFormer can in principle be layered onto existing VLA deployments without full retraining.
- **Honest limitations**: single-task validation, unproven on faster manipulation timescales, and the noise caveat on n=20 evaluation runs.

---

## Frequently Asked Questions

**What is ValueFormer and what problem does it solve?**
ValueFormer is a causal transformer critic that provides dense per-frame value signals to Vision-Language-Action policies trained by behavior cloning. It addresses the silent-failure problem: VLA policies trained by imitation have no internal notion of progress, so a failing rollout looks identical to a succeeding one from the action stream alone.

**How much does ValueFormer improve task completion?**
On a real-robot bimanual sandwich-assembly task evaluated across 1,427 episodes, ValueFormer lifted task completion from 70% to 85%. The authors note this improvement is within noise for individual runs at n=20.

**Does ValueFormer require reinforcement learning or a simulator?**
No. The entire approach is designed for settings where RL is impractical and sim-to-real transfer fails — specifically tasks involving deformable objects like food that resist accurate simulation.

**What makes the labeling scheme novel?**
Failed episodes are labeled with a stage-aware, success-then-decay return that preserves the success signal before the failure stage. Mistake detection is supervised from mistake intervals rather than a single failure timestamp, meaning partial recoveries carry useful training signal.

**Can ValueFormer be used with existing VLA policies without retraining?**
The policy-agnostic design — built on a frozen DINOv3 backbone with no access to policy internals — is intended to allow integration with existing trained VLAs. However, this has only been validated in the paper's specific experimental context.