Practice Makes Agents: How DPPO Turns Failure into Embodied Intelligence

Robots do not fail gracefully. They misread the scene, choose the wrong object, skip a physical constraint, hallucinate a plan, or produce a confident answer that would make a warehouse supervisor quietly unplug something expensive.

The usual response is more data. More robot trajectories. More simulation. More web video. More carefully labelled examples. More of the industrial-scale data plumbing that makes everyone feel productive until the model still cannot decide whether a cup should be placed inside the tray or beside it.

The Pelican-VL 1.0 paper argues for a different training philosophy: do not merely feed the model more experience; make the model practise the exact things it is bad at.¹ That sounds almost too human to be technical. Fortunately, the paper gives it machinery. Deliberate Practice Policy Optimization, or DPPO, is not just a motivational poster for robots. It is an iterative RL–SFT training loop that uses reinforcement learning to expose weaknesses, difficulty-aware sampling to select high-value failure cases, and supervised fine-tuning to consolidate those weaknesses into improved capability.

That distinction matters. The interesting claim is not “Pelican-VL scores well on embodied benchmarks”, although it does. The more useful claim is that embodied AI may need a training operating system: one that treats failure as a resource, not as waste.

The bottleneck is not just scarce data; it is badly allocated practice

Embodied intelligence sits at an awkward intersection. A model must perceive objects, reason about space, infer physical feasibility, understand temporal sequences, and generate action-relevant plans. In ordinary language tasks, a fluent guess can survive for a while. In embodied settings, fluency has a habit of colliding with furniture.

The field has largely pursued two routes. One is heterogeneous data scaling: combine web data, simulation, video, and real robot trajectories into ever-larger training mixtures. The other is architectural refinement: improve control, grounding, and action interfaces. Both are useful. Neither solves the deeper allocation problem.

Physical data is expensive, uneven, and long-tailed. Some tasks appear constantly; others appear rarely but matter disproportionately. A robot may see thousands of simple object-location examples and still struggle with physical causality, affordance, or long-horizon planning. Larger datasets can bury these weaknesses rather than repair them. Very elegant. Very expensive. Very enterprise.

DPPO starts from the opposite assumption: the model should not practise everything equally. It should spend training effort where the current policy is weak, where feedback is informative, and where supervision can actually move the boundary of competence.

That is why the mechanism has to come before the leaderboard.

DPPO turns RL into a diagnostic instrument

In standard descriptions, reinforcement learning is about maximising reward. DPPO uses RL more subtly. The RL phase is not merely a performance-improvement step; it is a weakness-discovery step.

The model performs rollouts on embodied tasks. These rollouts are scored with rule-based rewards covering six objectives: affordance reasoning, counting and distance estimation, causal and temporal reasoning, task success evaluation, task planning, and task prediction. The framework also uses a format reward to keep outputs structurally usable, including step-by-step reasoning and a final answer.

The important move is what happens next. DPPO computes a SuccessRate for each sample across rollouts. Samples the model already solves perfectly are discarded because they no longer provide meaningful learning signal. Samples the model fails completely are capped because too much hopeless failure can destabilise RL. The valuable zone is the middle: tasks hard enough to reveal a weakness, but not so hard that learning collapses into noise.

The paper also defines a stagnation score to decide when an RL round has stopped producing useful improvement. If a task is consistently solved, consistently failed, or no longer improving, the system treats it as saturated for that phase. The hardest unresolved cases are then transferred into the next SFT stage.

This is the central DPPO loop:

Roll out → score difficulty → identify weakness → stop when learning plateaus → convert hard cases into supervision → repeat.

That sounds simple because the idea is simple. The hard part is making the loop operational rather than inspirational.

SFT is not the boring half; it is the consolidation half

Supervised fine-tuning usually plays the role of “safe but limited” training. It teaches the model from positive examples, but cannot discover what the model does not know. RL, by contrast, can explore and compare alternatives, but can become unstable, overfit rewards, or forget general capabilities.

DPPO treats them as complementary rather than rival camps in the usual machine learning theology war.

After the RL phase identifies weaknesses, the SFT phase builds a targeted training set from three sources:

This is why the paper’s “deliberate practice” metaphor is more than branding. Human practice is not random repetition. It is targeted repetition with feedback, gradually moving from short, focused exercises toward longer, more compositional tasks. DPPO does something similar. The experiments use three metaloops, each consisting of an RL phase followed by an SFT phase, and progressively expand temporal coverage from shorter video segments toward longer trajectories.

The business point is straightforward: if supervision is expensive, then the question is not “how much data can we collect?” It is “which failures deserve the next dollar of annotation, teacher-model generation, human review, or hardware trial?”

The unified preference-learning view explains why the loop is not just duct tape

The paper also frames SFT and RL under a unified preference-learning objective. The full derivation lives in the appendix, but the practical intuition is enough for most readers.

SFT learns from positive exemplars. It increases the probability of expert-like trajectories. That makes it stable and useful for competence expansion, but it does not directly learn from the model’s own bad alternatives.

GRPO-style RL, used here as the RL component, works from ranked or comparative trajectory signals. It can learn from both better and worse outcomes, which makes it useful for detecting and suppressing subtle failure modes. The paper’s claim is not merely that “RL plus SFT works better”. It is that the two stages process different kinds of preference information.

One stage says: “Do more of this good behaviour.”

The other says: “This version was worse than that version, and here is where the policy boundary needs to move.”

That is a useful design pattern for embodied agents. It also applies beyond robotics. Any enterprise AI system that repeatedly handles operational tasks—claims review, inspection triage, compliance workflows, procurement checks—will eventually discover that generic fine-tuning is a blunt instrument. The model does not need more average examples. It needs structured attention to its recurring failure modes.

The main evidence: DPPO beats isolated RL and isolated SFT under the same data budget

The cleanest comparison in the paper is the 7B model experiment under the same data budget. This is main evidence, not a decorative appendix result, because it isolates the contribution of the training loop itself.

The result is not subtle. RL helps. SFT helps. DPPO helps more.

The interpretation is also more interesting than “hybrid methods win”. RL-only training improves several benchmarks but risks instability and forgetting. SFT-only training strengthens some task-specific performance but does not benefit from the diagnostic exploration that finds the model’s current weak spots. DPPO’s advantage comes from routing: use RL to discover where the model is failing, then use SFT to turn those failures into stable competence.

For business readers, this is the difference between a generic retraining cycle and an operational improvement loop. A generic retraining cycle says, “We added more data.” An improvement loop says, “We found the failure classes that hurt production performance, collected targeted supervision for them, and checked whether general capability degraded.” One of these sounds like engineering. The other sounds like procurement with GPUs.

The forgetting tests matter because improvement is useless if the model becomes narrower

Embodied fine-tuning can easily produce a specialist that forgets broader capabilities. The paper treats this as a live risk rather than a footnote. In the training evolution figure, Pelican-VL improves on embodied benchmarks while remaining stable on MVBench, used as a general-domain benchmark. A separate comparison across MMStar, RealWorldQA, and ScienceQA examines forgetting more directly.

The reported pattern is useful: DPPO achieves stronger embodied gains while showing smaller degradation on general benchmarks than pure RL or pure SFT. One figure highlights a performance gain of 54.3 on VSI-Bench with limited degradation on MMStar: 1.9 for DPPO, compared with 5.0 for SFT and 24.8 for RL.

That is not a deployment guarantee. It is a training-behaviour signal. It suggests that replaying general data during SFT and alternating phases can reduce the common trade-off between specialisation and broad competence.

This is especially relevant for embodied agents that need to operate as generalist “robot brains”. A warehouse robot does not merely need to recognise boxes. It needs to read instructions, identify objects, reason about placement, infer spatial constraints, and avoid doing something foolish when the scene differs from yesterday’s test setup. Narrow skill spikes are not enough.

The final benchmark table supports the claim, but it should not be worshipped

The headline result is that Pelican-VL 1.0 72B achieves a 20.3% uplift over its Qwen2.5-VL 72B base model and a 10.6% average advantage over 100B-scale open-source baselines. On the paper’s benchmark suite, Pelican-VL 72B reaches an average score of 63.8 in the 100B-level comparison, above Qwen3-VL-30B-A3B-Thinking at 57.7 and other listed open-source models.

Several individual gains are striking. Pelican-VL 72B scores 64.0 on Where2Place, compared with 38.1 for Qwen2.5-VL-72B-Instruct. It reaches 49.5 on RefSpatialBench, compared with 24.7 for the same base model. On EgoSchema it reaches 79.3, compared with 70.9 for the base model.

The paper also compares against larger closed or proprietary systems under a unified evaluation protocol, including models above 200B parameters. Pelican-VL remains competitive overall and performs especially well on several embodied dimensions. Useful, yes. Final verdict on “better robot intelligence than proprietary frontier models”? No. The authors themselves note prompt sensitivity in some baseline comparisons, and unified protocols can change model rankings.

The right reading is narrower and stronger: DPPO appears to move a 72B vision-language model toward embodied competencies that scale alone does not reliably solve.

The nine-dimensional diagnostic analysis is the quiet business lesson

The paper’s fine-grained capability analysis deserves more attention than the average score table. Existing embodied benchmarks often collapse performance into pass/fail task metrics. That is convenient for leaderboards and bad for improvement. If a model fails, a pass/fail score does not tell you whether the problem was spatial grounding, temporal reasoning, physical causality, affordance, or planning.

To address this, the authors re-annotate 27,667 samples from public datasets into a nine-dimensional taxonomy:

The re-labelling analysis shows that existing datasets are heavily imbalanced. Spatial and geometric reasoning accounts for 30.6% of the analysed samples, quantitative and numerical reasoning for 22.2%, and scene/action understanding for 19.4%. Meanwhile, physical and causal reasoning is only 3.5%, affordance and function reasoning 2.3%, and decision and task planning 3.3%.

That imbalance is not a minor benchmark design issue. It is a map of why embodied AI can look good in demos and still fail operationally. Real-world agents need precisely the neglected categories: physical feasibility, affordance, long-horizon planning, and causal reasoning. Naturally, those are the expensive ones. Reality has terrible annotation ergonomics.

The authors report that Pelican-VL improves most strongly in difficult and underrepresented dimensions, with an average uplift of 15.4% across the nine reasoning dimensions. This is why the diagnostic taxonomy matters: it turns “the model improved” into “the model improved where embodied systems are usually starved of signal.”

The appendix tests are not a second thesis; they stress the routing claim

Several appendix results are best read as robustness and mechanism checks.

The random-sampling comparison is an ablation of difficulty-aware selection. Under the same data budget, replacing difficulty-aware sampling with random data destabilises the process. By the second RL stage, the model collapses into producing only final answers and loses chain-of-thought reasoning ability, marked as missing results in the table. This supports the claim that the data-routing mechanism is not decorative. Choosing the wrong practice set can break the loop.

The chain-of-thought comparison is a reasoning-behaviour test. It compares step-by-step CoT evaluation with direct-answer prediction across stages. By the third stage, direct-answer performance improves only marginally, while CoT accuracy continues rising by more than 5% on several datasets. That suggests later cycles still strengthen reasoning behaviour, even when final-answer metrics begin to flatten.

The t-SNE representation analysis is exploratory evidence, not proof of mechanistic causality. It visualises how trajectory embedding centroids move across DPPO cycles and benchmarks. The authors interpret divergent benchmark trajectories as evidence that different tasks pull representations in different directions, making a single training stage insufficient. Useful signal, but not something to oversell. t-SNE is an interpretive flashlight, not a courtroom witness.

What this means for business: cheaper diagnosis, not magical autonomy

The immediate business relevance is not that DPPO makes robots production-ready. It does not prove that. The experiments are benchmark-heavy, reward functions are rule-based, training data is curated, and the paper does not close the loop with messy hardware deployment. A benchmark can ask whether a robot should place an object somewhere. A warehouse asks whether the robot still behaves sensibly when lighting changes, the item is damaged, the bin is half-blocked, and a human is standing inconveniently nearby.

The practical lesson is more operational: build AI improvement systems around failure routing.

For robotics and physical-agent businesses, this means logging model failures in a way that preserves task context, capability category, and outcome. It means ranking failures by learnability and business cost. It means sending only the right subset to expensive human review, teacher-model generation, simulation replay, or hardware testing. It means mixing targeted correction with general replay so the system does not become a brittle specialist.

The same pattern applies to enterprise agents outside robotics:

This is the grown-up version of “continuous learning”. Not a vague promise that the system improves itself in production. A controlled loop: observe, classify, select, correct, replay, evaluate.

Less glamorous. Much more useful.

The boundary: DPPO is a training framework, not a deployment certificate

DPPO’s strength is also its boundary. It improves the way embodied VLMs learn from finite data. It does not solve every problem in embodied autonomy.

First, rule-based rewards work when tasks can be evaluated with structured criteria. Many real-world robotic behaviours have ambiguous success conditions, safety constraints, or delayed consequences. Reward design remains a bottleneck.

Second, the method depends on curated data and teacher-model support. The appendix describes substantial data construction, filtering, model-based scoring, voting, and random human review. That is efficient compared with brute-force data scaling, but it is not free. Failure routing reduces waste; it does not abolish labour.

Third, benchmark gains are not the same as field reliability. The paper reports strong results across public embodied benchmarks and diagnostic dimensions, but it does not demonstrate sustained autonomous operation under live hardware constraints. Latency, actuation error, sensor noise, safety interlocks, edge cases, and recovery behaviour remain outside the main evidence.

Fourth, the comparison with proprietary models should be read carefully. The unified evaluation protocol is helpful, but model-specific prompts and evaluation settings can materially affect performance. The paper is strongest when showing DPPO’s improvement over its own base model and over isolated RL/SFT variants under controlled conditions.

None of this weakens the paper’s core contribution. It simply prevents a research result from being inflated into a product brochure. A rare and refreshing discipline, I know.

The real contribution is a new unit of training value: the useful failure

The old instinct is to ask how much data an embodied model has seen. DPPO asks a better question: what did the model fail at, and did the training process turn that failure into reusable competence?

That is a more mature way to think about agent development. As AI systems move from chat interfaces into operational environments, average-case fluency becomes less interesting. The limiting factor is the system’s ability to find, classify, and repair the specific behaviours that block deployment.

Pelican-VL 1.0 shows that this can be done in a structured RL–SFT metaloop. RL exposes weaknesses. Difficulty-aware sampling decides which failures deserve attention. SFT consolidates targeted corrections. General replay prevents the model from forgetting everything useful while it learns to place the cup correctly. A small mercy for both robotics and common sense.

The result is not a robot that can be trusted anywhere. It is a training pattern that deserves attention: deliberate practice as infrastructure.

In other words, embodied intelligence may not arrive by giving models ever-larger childhoods. It may arrive by teaching them how to study.

Cognaptus: Automate the Present, Incubate the Future.