Restructure blog from paper format to chronological narrative

Reorganize Train/Eval/Experiments sections so the reader follows
the iterative journey rather than seeing all settings then all results.

- Simplify 05 to Data Overview (filtering/SARM details move to journey)
- Merge 06 (Training) + 07 (Evaluation) into Model and Evaluation Setup
- Remove 07 import from article.mdx (content now in 06)
- Rewrite 08 as chronological narrative: baseline → data curation →
algorithmic improvements (SARM, RABC, relative actions, DAgger) →
breakthrough with high-quality data → what didn't work → full comparison
- Slim 09 Learnings (DAgger now covered in journey chapter)

Made-with: Cursor

app/src/content/article.mdx

@@ -56,7 +56,6 @@ import Hardware from "./chapters/folding/03-hardware.mdx";
 import DataCollection from "./chapters/folding/04-data-collection.mdx";
 import DataDiversity from "./chapters/folding/05-data-diversity.mdx";
 import Training from "./chapters/folding/06-training.mdx";
-import Evaluation from "./chapters/folding/07-evaluation.mdx";
 import Experiments from "./chapters/folding/08-ablations.mdx";
 import Learnings from "./chapters/folding/09-learnings.mdx";
 import References from "./chapters/folding/12-references.mdx";
@@ -82,8 +81,6 @@ import VibeCodingCharts from "./chapters/demo/vibe-coding-charts.mdx";
 
 <Training />
 
-<Evaluation />
-
 <Experiments />
 
 <Learnings />

app/src/content/chapters/folding/05-data-diversity.mdx

@@ -1,18 +1,13 @@
-import Note from "../../../components/Note.astro";
-import Sidenote from "../../../components/Sidenote.astro";
 import Wide from "../../../components/Wide.astro";
-import Accordion from "../../../components/Accordion.astro";
 import diversityGridImg from "../../assets/image/lerobot-data-collection_level12_rac_2_2026-02-08_1_grid_15x10.jpg";
 
-## Data and Diversity
+## Data Overview
 
-Raw episodes are only the beginning. What you do with them before training determines whether your model learns to fold or learns to fumble.
-
-We collected two datasets: a **full dataset** containing every episode, and a **curated dataset** built by selecting the best episodes from the full set and supplementing them with additional high-quality recordings.
+After weeks of collection we had **5,688 episodes** across 8 setups. Not all of them are equally useful — later we curated a smaller, high-quality subset. Here are both datasets side by side:
 
 ### Dataset Statistics
 
-| Metric | Large dataset | High-quality dataset |
+| Metric | Full dataset | High-quality dataset |
 |:---|:---:|:---:|
 | Total episodes | **5,688** | **1,200** |
 | Total frames | **14.1M** | **3.2M** |
@@ -29,23 +24,10 @@ The grid below shows one frame from each of 100 different episodes. Notice the v
 <img src={diversityGridImg.src} alt="Trajectory diversity grid showing variation in t-shirt color, background, camera viewpoint, and robot height" style="width:100%; border-radius: 8px;" />
 </Wide>
 
-### Data Augmentation and Curation
-
-#### Filtering
-
-We filtered episodes in two ways:
-
-1. **End-state image filtering** to discard episodes where the final frame doesn't show a properly folded shirt. If the end result isn't good, the demonstration isn't useful.
-2. **Length-based filtering** using the LeRobot data visualizer to remove outliers. Episodes that are suspiciously short tend to be low quality.
-
-The [LeRobot Data Visualizer](https://huggingface.co/spaces/lerobot/visualize_dataset) was invaluable for inspecting the dataset, spotting outliers, and understanding distributions. Try it right here with our dataset:
+Explore the dataset yourself with the [LeRobot Data Visualizer](https://huggingface.co/spaces/lerobot/visualize_dataset):
 
 <Wide>
 <div className="card" style="overflow: hidden; border-radius: 10px;">
   <iframe src="https://lerobot-visualize-dataset.hf.space/?path=%2Flerobot%2Fhigh_quality_folding%2Fepisode_0" width="100%" height="800" frameBorder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" style="border: none;"></iframe>
 </div>
 </Wide>
-
-#### SARM Annotation
-
-We also annotated every episode using our trained **[Stage-Aware Reward Modeling (SARM)](https://huggingface.co/docs/lerobot/sarm)** reward model. This gave us continuous scores we could use as weights at training time. More details in [SARM: Our Reward Model](#sarm-our-reward-model).

app/src/content/chapters/folding/06-training.mdx

@@ -2,16 +2,11 @@ import Note from "../../../components/Note.astro";
 import Sidenote from "../../../components/Sidenote.astro";
 import Accordion from "../../../components/Accordion.astro";
 import Wide from "../../../components/Wide.astro";
-import Stack from "../../../components/Stack.astro";
 import HtmlEmbed from "../../../components/HtmlEmbed.astro";
 
-import sarmEp300 from "../../assets/image/lerobot-data-collection_level2_final_quality3_ep300_progress.gif";
-import sarmEp2500 from "../../assets/image/lerobot-data-collection_level12_rac_2_2026-02-08_1_ep2500_progress.gif";
-import sarmEp2200 from "../../assets/image/lerobot-data-collection_level12_rac_2_2026-02-08_1_ep2200_progress.gif";
+## Model and Evaluation Setup
 
-## Training
-
-Before talking about hyperparameters, one needs to understand what the trained model actually *is*: what it takes in, what it produces, and why those choices matter for cloth folding.
+Before diving into experiments, let's establish the model architecture we're training and how we measure performance. These stay constant across every iteration.
 
 ### Model Architecture
 
@@ -33,8 +28,6 @@ The model generates actions through **flow matching**, a generative approach tha
   Flow matching is closely related to diffusion models but uses a simpler, more direct interpolation path between noise and data. 
 </Sidenote>
 
-Before diving further into the model architecture, let's introduce a few key ingredients: [RTC](https://huggingface.co/docs/lerobot/rtc), [SARM](https://huggingface.co/docs/lerobot/sarm) and [relative actions](https://huggingface.co/docs/lerobot/action_representations).
-
 #### [Real-Time Chunking (RTC)](https://huggingface.co/docs/lerobot/rtc)
 
 RTC is crucial for real-world deployment. Instead of waiting for the predicted action chunk to finish before generating the next, RTC generates the next chunk while executing the current one. It "freezes" actions that are already committed and "inpaints" the remaining ones, producing smooth asynchronous motion. In practice, this sped up our rollouts by at least a factor of 2.
@@ -50,38 +43,11 @@ sequenceDiagram
     end
 ```
 
-#### [Stage-Aware Reward Modeling (SARM)](https://huggingface.co/docs/lerobot/sarm)
-
-SARM is a trained reward model that scores trajectories based on how well the robot is progressing toward task completion, it acts as a learned "critic" that predicts whether things are going well or badly.
-
-SARM is trained on our demonstration data to predict 0-1 task progression. The takeaway: it correctly identifies **mistakes** (drops in value) and **progress** (increases) in real time.
-
-<Wide>
-<Stack layout="3-column" gap="small">
-  <img src={sarmEp300.src} alt="SARM annotation on episode 300" style="width:100%; border-radius: 8px;" />
-  <img src={sarmEp2500.src} alt="SARM annotation on episode 2500" style="width:100%; border-radius: 8px;" />
-  <img src={sarmEp2200.src} alt="SARM annotation on episode 2200" style="width:100%; border-radius: 8px;" />
-</Stack>
-</Wide>
-
-We use SARM exclusively for **RABC** (Reward-Advantage-Based Conditioning): every episode is scored with a per-timestep quality signal, and during training, actions are weighted by their contribution to progress. High-reward actions contribute more to the loss, low-reward ones contribute less. Negative progress is clipped to 0. Unlike binary success/fail labels, SARM provides a continuous signal at every timestep.
-
-#### [Relative actions representation](https://huggingface.co/docs/lerobot/action_representations)
-
-Following [UMI](https://arxiv.org/abs/2402.10329) approach, actions are expressed as **relative trajectories**: each action in the chunk is an offset from the robot's current state at prediction time, not from the previous action. This avoids error accumulation (unlike true delta) and doesn't require a global coordinate frame (unlike absolute). 
-
-<HtmlEmbed
-  id="action-representations"
-  src="folding/action-representations.html"
-  title="Action Representations"
-  desc="Relative trajectory (blue) references all actions to the current state. Delta (yellow) chains each action to the previous one, accumulating error. Absolute (red) requires a global coordinate frame. Diagram adapted from UMI (Chi et al., 2024)."
-/>
-
-See the [LeRobot action representations docs](https://huggingface.co/docs/lerobot/action_representations) for a full guide on how to use relative actions in your own training.
+All experiments use **RTC** with an action queue size of 30 and a maximum action horizon of 20, along with **action interpolation** (upsampling from 30 Hz to 90 Hz) which makes the robot much quieter and smoother.
 
 ### Models
 
-We initially trained multiple architectures supported in LeRobot, but we ended up focusing on two VLA architectures for our cloth folding data:
+We focused on two VLA architectures for our cloth folding data:
 
 - **π0** the base flow-matching VLA, trained with standard imitation learning
 - **[π0.5](https://huggingface.co/docs/lerobot/pi05)** an improved variant with more pretraining and several improvements to the flow matching denoising process
@@ -97,22 +63,67 @@ Both are finetuned from pretrained checkpoints. Starting from this pretrained fo
 | Action chunk size | **30** |
 | Optimizer | AdamW |
 | Learning rate | **1e-4** (with warmup + cosine decay) |
-| Training steps | **200k** (Series 1) / **100k** (Series 2 fine-tune) |
 
 <Sidenote>
   Multi-GPU training with 8xH100 and gradient accumulation was necessary to fit the large batch sizes needed for stable VLA training.
 </Sidenote>
 
-### Loss Curves
+---
 
-<Wide>
-<HtmlEmbed
-  id="loss-curves"
-  src="folding/loss-curves.html"
-  title="Training Loss"
-  desc="Click legend entries to toggle runs. <strong>Series 1</strong>: trained from pretrained checkpoints on full data (200k steps). <strong>Series 2</strong>: fine-tuned on curated high-quality data (100k steps)."
-  frameless
-/>
-</Wide>
+### Evaluation Protocol
+
+**Evaluation is as hard as training.** In robotics and with real hardware, no standardized benchmarks exist. If your evaluation protocol is inconsistent, every downstream decision will be wrong.
+
+For every experiment, we evaluate the model on:
+
+- **5 different t-shirts for Level 1** (laid-out to fold)
+- **5 different t-shirts for Level 2** (messy to spread to fold, then place aside)
+
+Each t-shirt fold is attempted **twice consecutively**, giving **10 rollouts per level** and **20 rollouts total per experiment**. Every evaluation is filmed and scored from video afterward, so judgment is decoupled from execution.
+
+<Note>
+  The evaluation protocol t-shirts, attempts count, scoring rubric, and filming setup is identical across every experiment.
+</Note>
+
+### Metrics
+
+We report four complementary metrics:
+
+1. **Success Rate** Binary pass/fail per rollout.
+2. **Score** Partial credit based on subtasks completed. This distinguishes a model that consistently reaches Fold 3 from one that fails at Unfold, even if neither achieves full success.
+
+<Accordion title="Scoring rubric Level 1 and Level 2">
+
+**Level 1** Laid-out shirt to fold (shirt starts flat):
+
+| Subtask | Points |
+|:---|:---:|
+| Do first horizontal fold | +10 |
+| Do second horizontal fold | +10 |
+| Do third vertical fold | +10 |
+| Do final fold | +10 |
+| Rotate | +10 |
+| **Maximum per rollout** | **50** |
+
+**Level 2** Messy shirt to spread, fold, and place aside:
+
+| Subtask | Points |
+|:---|:---:|
+| Unfold (spread the shirt) | +50 |
+| Fold 1 | +10 |
+| Fold 2 | +10 |
+| Fold 3 | +10 |
+| Fold 4 | +10 |
+| Rotation + Place aside | +10 |
+| **Maximum per rollout** | **100** |
+
+Scores are summed across all the rollouts in an experiment. With 10 Level 1 rollouts (max 50 points each) and 10 Level 2 rollouts (max 100 points each), the **maximum total score per experiment is 1,500 points**.
+
+</Accordion>
+
+3. **Fold quality** A 1–5 rating of the final fold appearance, averaged across successful rollouts.
+4. **Completion time** Seconds to complete Level 1/Level 2, averaged across successful rollouts.
+
+### Statistical uncertainty
 
-Our training followed two phases: **Series 1** trained from pretrained base checkpoints on the full dataset for 200k steps. **Series 2** fine-tuned the best Series 1 checkpoint on curated high-quality data for 100k steps.
+With 20 rollouts per experiment, even large apparent differences can be statistically indistinguishable. We report **Clopper-Pearson 90% confidence intervals** on all success rates and run formal pairwise significance tests using [STEP](https://tri-ml.github.io/step/) (Sequential Testing for Efficient Policy comparison). Running 50-100 rollouts per experiment would give tighter estimates but was not feasible for us across 11 experiments on real hardware.

app/src/content/chapters/folding/08-ablations.mdx

@@ -1,12 +1,160 @@
 import Note from "../../../components/Note.astro";
 import Sidenote from "../../../components/Sidenote.astro";
 import Wide from "../../../components/Wide.astro";
+import Stack from "../../../components/Stack.astro";
 import Accordion from "../../../components/Accordion.astro";
 import HtmlEmbed from "../../../components/HtmlEmbed.astro";
 
-## Experiments
+import sarmEp300 from "../../assets/image/lerobot-data-collection_level2_final_quality3_ep300_progress.gif";
+import sarmEp2500 from "../../assets/image/lerobot-data-collection_level12_rac_2_2026-02-08_1_ep2500_progress.gif";
+import sarmEp2200 from "../../assets/image/lerobot-data-collection_level12_rac_2_2026-02-08_1_ep2200_progress.gif";
 
-We ran 11 experiments to understand what *actually* matters. **Series 1** trains from pretrained base checkpoints on the full dataset. **Series 2** finetunes Series 1 checkpoints on curated high-quality data (2.1–2.4 from 1.3, 2.5 from 1.7). One early lesson: **undertraining makes the policy shaky** - make sure your model has converged before drawing conclusions.
+## From Data to Deployment
+
+With the data collected, hardware running, and evaluation protocol fixed, we began training. What follows is the chronological story of how we iterated from a barely-working baseline to a 90% success rate, and what we learned at each step.
+
+### First attempt: training on all data
+
+We started with the simplest possible recipe: train π0 and π0.5 on the full dataset of 5,688 episodes for 200k steps each.
+
+| Experiment | Model | Data | Steps | Key change |
+|:---:|:---:|:---|:---:|:---|
+| 1.1 | π0 | All data (5,688 episodes) | 200k | Baseline |
+| 1.2 | π0.5 | All data (5,688 episodes) | 200k | Baseline |
+
+The loss curves show both models converging, but convergence of loss for robotics doesn't necessarily mean good performance:
+
+<Wide>
+<HtmlEmbed
+  id="loss-curves"
+  src="folding/loss-curves.html"
+  title="Training Loss"
+  desc="Click legend entries to toggle runs. <strong>Series 1</strong>: trained from pretrained checkpoints on full data (200k steps). <strong>Series 2</strong>: fine-tuned on curated high-quality data (100k steps)."
+  frameless
+/>
+</Wide>
+
+When we evaluated, the results were disappointing. Experiment 1.1 (π0) achieved 40% Level 1 success but 0% Level 2. Experiment 1.2 (π0.5) managed only 20% total success rate, also with 0% Level 2. The models could sometimes fold a laid-out shirt, but they were slow, and produced poor-quality folds. Level 2, spreading a messy shirt before folding was completely out of reach.
+
+Watching the rollouts, the problem was clear: the policy had learned the *average* of many different folding strategies in the dataset. Different operators used different grip points, different fold sequences, and different speeds. The model averaged over all of them, producing indecisive, hesitant motions.
+
+One early lesson: **undertraining makes the policy shaky**. Make sure your model has converged before drawing conclusions about what works.
+
+---
+
+### Improving the data
+
+Before adding algorithmic complexity, we addressed the data quality problem directly.
+
+#### Filtering
+
+We filtered episodes in two ways:
+
+1. **End-state image filtering** to discard episodes where the final frame doesn't show a properly folded shirt. If the end result isn't good, the demonstration isn't useful.
+2. **Length-based filtering** using the LeRobot data visualizer to remove outliers. Episodes that are suspiciously short tend to be low quality.
+
+#### Stage-Aware Reward Modeling (SARM)
+
+To go beyond binary keep/discard filtering, we trained a reward model: **[SARM](https://huggingface.co/docs/lerobot/sarm)** (Stage-Aware Reward Modeling). SARM is a learned "critic" that scores trajectories based on how well the robot is progressing toward task completion. It predicts a 0–1 progression signal at every timestep, correctly identifying **mistakes** (drops in value) and **progress** (increases) in real time:
+
+<Wide>
+<Stack layout="3-column" gap="small">
+  <img src={sarmEp300.src} alt="SARM annotation on episode 300" style="width:100%; border-radius: 8px;" />
+  <img src={sarmEp2500.src} alt="SARM annotation on episode 2500" style="width:100%; border-radius: 8px;" />
+  <img src={sarmEp2200.src} alt="SARM annotation on episode 2200" style="width:100%; border-radius: 8px;" />
+</Stack>
+</Wide>
+
+We annotated every episode in both datasets using SARM. This gave us continuous per-timestep quality scores that we could use in two ways: for **data curation** (scoring and ranking episodes) and for **reward-weighted training** (which we introduce next).
+
+---
+
+### Algorithmic improvements
+
+With cleaner data and SARM scores in hand, we systematically tested three algorithmic improvements.
+
+#### Relative actions
+
+Following the [UMI](https://arxiv.org/abs/2402.10329) approach, we switched from absolute actions to **relative trajectories**: each action in the chunk is an offset from the robot's current state at prediction time, not from the previous action. The state observation remains absolute — only the action targets are relative. This avoids error accumulation (unlike true delta) and doesn't require a global coordinate frame (unlike absolute).
+
+<HtmlEmbed
+  id="action-representations"
+  src="folding/action-representations.html"
+  title="Action Representations"
+  desc="Relative trajectory (blue) references all actions to the current state. Delta (yellow) chains each action to the previous one, accumulating error. Absolute (red) requires a global coordinate frame. Diagram adapted from UMI (Chi et al., 2024)."
+/>
+
+See the [LeRobot action representations docs](https://huggingface.co/docs/lerobot/action_representations) for a full guide.
+
+The result: experiment 1.3 (π0.5 + relative actions + quantile normalization) jumped to **35% total success rate and 70% Level 1**, up from 1.2's 20% total and 40% Level 1. The improvement was consistent across every comparison we made.
+
+<Sidenote>
+  π0.5 is likely pretrained with relative actions, so 1.3 fine-tunes in a regime consistent with pretraining, while 1.2 fine-tunes against it.
+</Sidenote>
+
+#### RABC (Reward-Advantage-Based Conditioning)
+
+Next, we put SARM's per-timestep scores to work during training. With **RABC**, every episode is weighted by its contribution to progress: high-reward actions contribute more to the loss, low-reward ones contribute less. Negative progress is clipped to 0. Unlike binary success/fail labels, this provides a continuous signal at every timestep.
+
+Experiments 1.4 and 1.5 tested RABC with different κ values (0.01 and 0.0215). Both showed improvement, with 1.5's higher κ performing slightly better.
+
+#### Combining everything
+
+Experiment 1.7 combined all three improvements: **relative actions + RABC + quantile normalization**. The result: **40% total success rate, 80% Level 1** — the best of Series 1.
+
+| Experiment | Key change | Total SR | Level 1 SR | Level 2 SR |
+|:---:|:---|:---:|:---:|:---:|
+| 1.1 | π0 baseline | 20% | 40% | 0% |
+| 1.2 | π0.5 baseline | 20% | 40% | 0% |
+| 1.3 | + Relative actions | 35% | 70% | 0% |
+| 1.4 | + RABC (κ=0.01) | 25% | 50% | 0% |
+| 1.5 | + RABC (κ=0.0215) | 30% | 60% | 0% |
+| 1.7 | Relative + RABC + QUANTILES | **40%** | **80%** | **0%** |
+
+The trend was encouraging, but one number was impossible to ignore: **every Series 1 experiment achieved exactly 0% Level 2 success**. Algorithmic improvements alone couldn't compensate for the inconsistency in the full dataset.
+
+#### DAgger: targeted corrections
+
+We also explored **DAgger** (Dataset Aggregation) as a way to fix specific failure modes. The idea: the operator watches the policy run, pauses when it fails, teleoperates a recovery, and hands control back. This generates correction data precisely where the model struggles.
+
+DAgger felt promising — corrections targeting the model's actual failure modes should be highly effective at pushing success rates higher. The full [Human-in-the-Loop infrastructure](https://github.com/huggingface/lerobot/tree/main/examples/hil) is now merged into LeRobot for anyone to use.
+
+---
+
+### The breakthrough: high-quality data
+
+No Series 1 experiment cracked Level 2. We needed a fundamentally better dataset.
+
+We went back to data collection with a clear plan: collect new demonstrations specifically for Level 1 and Level 2, with a **unified strategy** across operators. Every episode followed the same grip points, the same fold sequence, the same timing. We also manually curated the best episodes from the large dataset, selecting only those with consistent technique and clear progress.
+
+The result was the **high-quality dataset**: 1,200 episodes combining the best of the original data with new, strategically collected demonstrations. Less data, but dramatically better data.
+
+**Series 2** fine-tuned the best Series 1 checkpoints on this curated dataset for 100k steps:
+
+| Experiment | Base | Key change | Total SR | Level 1 SR | Level 2 SR |
+|:---:|:---:|:---|:---:|:---:|:---:|
+| 2.1 | 1.3 | HQ data only | 35% | 70% | 0% |
+| 2.2 | 1.3 | HQ + RABC + Relative | **75%** | **100%** | **50%** |
+| 2.5 | 1.7 | HQ + RABC + Relative | **90%** | **100%** | **80%** |
+
+The jump was dramatic. Experiment 2.5 reached **90% total success rate** — 100% Level 1, 80% Level 2 — up from 40% in Series 1. The same architecture, the same training recipe, just better data.
+
+Both 2.2 and 2.5 used the same recipe (HQ + RABC + Relative Actions), but 2.5 fine-tuned from 1.7 (the stronger base with relative actions + RABC already baked in) while 2.2 fine-tuned from 1.3. The difference (75% → 90%) likely reflects this stronger starting point. Data quality was the single biggest lever, and RABC's effect was strongest on **Level 2** — the longer, harder task where emphasizing the best demonstrations mattered most.
+
+---
+
+### What didn't work
+
+Not every idea improved results:
+
+- **Mirroring augmentation** (experiment 2.3): only 5% total success rate. Mirroring the data doubles the number of valid strategies the model sees, which is the opposite of what we needed — convergence on a single consistent approach.
+- **Larger chunk size** (experiment 2.4, chunk=45): no improvement over the default chunk size of 30.
+
+---
+
+### Full comparison
+
+Now that the full journey is clear, here is the complete picture across all 11 experiments.
 
 <Wide>
 
@@ -26,16 +174,6 @@ We ran 11 experiments to understand what *actually* matters. **Series 1** trains
 
 </Wide>
 
-All experiments use **[RTC](https://huggingface.co/docs/lerobot/rtc)** (Real-Time Chunking) with an action queue size of 30 and a maximum action horizon of 20, along with **action interpolation** (upsampling from 30 Hz to 90 Hz).
-
-RTC gave us a ~2x speedup (sometimes even 2.5x) and action interpolation made the robot much quieter and smoother. Both are now available on [LeRobot repository](https://github.com/huggingface/lerobot).
-
----
-
-### Results Overview
-
-Now let's look at how each experiment actually performed. The charts below show success rates, scores, completion times, and failure modes across all 11 experiments. The pattern is consistent: **Series 2 dominates Series 1**, and within each series, RABC combined with relative actions produces the best results. We break down the key findings below.
-
 <HtmlEmbed
   id="success-rates"
   src="folding/success-rates.html"
@@ -43,8 +181,6 @@ Now let's look at how each experiment actually performed. The charts below show
   desc="Success rates (Total, Level 1, Level 2) across all experiments. Series 1 trains from scratch on full data; Series 2 finetunes the best Series 1 checkpoint on curated high-quality data."
 />
 
-The gap between Series 1 and Series 2 is immediately visible. Experiment 2.5 reaches 90% total success rate (100% Level 1, 80% Level 2), while the best Series 1 result tops out at 40%. No Series 1 experiment achieves a single Level 2 success.
-
 <HtmlEmbed
   id="total-score"
   src="folding/total-score.html"
@@ -52,7 +188,7 @@ The gap between Series 1 and Series 2 is immediately visible. Experiment 2.5 rea
   desc="Overall score (% of maximum 1500) per experiment. The dashed line marks 50% as a reference point."
 />
 
-Total score captures partial progress that binary success rate misses. Even failed rollouts earn credit for completed subtasks, revealing that some Series 1 experiments make meaningful progress despite 0% Level 2 success. Only two experiments break the 50% threshold, all from Series 2.
+Total score captures partial progress that binary success rate misses. Even failed rollouts earn credit for completed subtasks, revealing that some Series 1 experiments make meaningful progress despite 0% Level 2 success.
 
 <HtmlEmbed
   id="l1-time-quality"
@@ -61,7 +197,7 @@ Total score captures partial progress that binary success rate misses. Even fail
   desc="Each bubble is one experiment. X-axis = completion time (faster is left), Y-axis = fold quality (higher is better), bubble size = total success rate. The best experiments cluster in the top-left corner."
 />
 
-Speed and quality correlate strongly with data quality. Series 2 experiments fold 2-3x faster than Series 1 (40s vs 100s+), and fold quality only breaks past 3.0 with high-quality training data. Faster isn't a separate goal from better; it's a consequence of the policy learning a clear, unambiguous strategy.
+Speed and quality correlate strongly with data quality. Series 2 experiments fold 2–3x faster than Series 1 (40s vs 100s+), and fold quality only breaks past 3.0 with high-quality training data. Faster isn't a separate goal from better — it's a consequence of the policy learning a clear, unambiguous strategy.
 
 <HtmlEmbed
   id="subtask-heatmap"
@@ -70,11 +206,9 @@ Speed and quality correlate strongly with data quality. Series 2 experiments fol
   desc="Average time (seconds) per subtask across all experiments. Green is fast, red is slow. Dashes indicate the subtask was never completed."
 />
 
-The heatmap shows where time is spent. Series 1 experiments are slow across the board, especially on Unfold. Series 2 compresses most subtasks to under 10 seconds, with the remaining time concentrated on Unfold for Level 2, which is inherently the most complex step.
-
 ### Where the policies fail
 
-Before interpreting success rates, understanding *how* each experiment fails — not just whether it fails — is essential.
+Understanding *how* each experiment fails — not just whether it fails — is essential for knowing what to try next.
 
 <HtmlEmbed
   id="failure-analysis"
@@ -95,63 +229,3 @@ With 20 rollouts per experiment, not every visible gap is real. We run **[STEP](
 />
 
 The CLD tells a clear story: **Series 2 separates from Series 1**. Experiments 2.5 and 2.2 form group 'a' — statistically distinct from the bulk of Series 1 experiments which cluster in groups 'c' and 'd'. Within Series 1, no experiment separates from another, meaning none of the algorithmic changes (RABC, relative actions, normalization) produced a statistically detectable improvement on their own when trained on the full dataset. The jump only comes from switching to curated high-quality data in Series 2. Toggle to Level 2 and the separation is even starker: every Series 1 experiment sits in group 'b' with 0% success, while 2.5 stands alone in group 'a'.
-
----
-
-### Key Findings
-
-#### 1. Data quality matters most
-
-This is the finding we're most confident in it held regardless of which confidence level or correction method we used. The best Series 1 result (1.7) achieves 40% total success rate. The best Series 2 result (2.5) achieves 90% using the *same architecture*. The pairwise tests cleanly separate these two groups, and no amount of algorithmic tuning within Series 1 came close to closing the gap.
-
-We hypothesise that the root cause is the difference in **multi-modality** between the high-quality and full dataset. The full dataset contains demonstrations with some inconsistent strategies: different grips, unfolding sequences, and timing, while the high-quality dataset enforces a more unified, consistent protocol.
-
-<Note variant="info" emoji="💡">
-  Define the exact task protocol before collecting data. Speed is secondary to consistency and clarity of intent at every step.
-</Note>
-
-#### 2. Relative actions improve performance consistently
-
-Comparing π0.5 without relative actions (1.2: 20% total SR, 40% Level 1) to π0.5 with relative actions and quantile normalization (1.3: 35% total SR, 70% Level 1), and then to the full combination in 1.7 (40% total SR, 80% Level 1), shows that training with relative actions consistently improves performance. The trend is clear and shows up in every comparison we made.
-
-With only 20 rollouts, the exact gap between experiments is hard to pin down, but the improvement is consistent across every comparison. **Caveat:** π0.5 is likely pretrained with relative actions, so 1.3 and 1.7 fine-tune in a regime consistent with pretraining, while 1.2 fine-tunes against it.
-
-#### 3. RABC helps especially on long tasks like level 2
-
-RABC on high-quality data yields the two best results overall: experiments 2.2 and 2.5 clearly outperform every experiment that lacks it. The effect is strongest on **Level 2**, the longer and harder task — 2.2 reaches 50% Level 2 SR and 2.5 reaches 80%, while every experiment without RABC on clean data stays at 0%. 
-
-#### 4. Fine-tuning from a strong checkpoint is the winning recipe
-
-The best results share the same recipe: fine-tune a Series 1 checkpoint on curated high-quality data with RABC and relative actions.
-
-| Experiment | Total SR | Level 1 SR | Level 2 SR | Recipe |
-|:---:|:---:|:---:|:---:|:---|
-| 2.5 | **90%** | **100%** | **80%** | 1.7 → HQ + RABC, 100k steps |
-| 2.2 | 75% | 100% | 50% | 1.3 → HQ + RABC, 100k steps |
-| 1.7 | 40% | 80% | 0% | All data, Relative Actions + RABC + QUANTILES |
-
-The jump from Series 1 to Series 2 is unambiguous in the statistical analysis — 2.5 and 2.2 clearly stand out from the Series 1 group. The Series 1 checkpoint already knows how to fold shirts in general, the high-quality data teaches the correct protocol, and RABC emphasizes the best demonstrations within an already clean dataset.
-
-Both 2.2 and 2.5 were trained for 100k steps. 2.2 fine-tunes from 1.3 while 2.5 fine-tunes from 1.7 (the stronger base). The difference (75% → 90%) likely reflects this stronger starting point. They don't separate from each other in the pairwise tests, suggesting the recipe itself (HQ + RABC + Relative Actions) is the key ingredient, with the base checkpoint providing an additional boost.
-
-#### 5. Level 2 requires everything to be right simultaneously
-
-Every Series 1 experiment achieves exactly **0% Level 2 success**. Level 2 only becomes tractable in Series 2, and only with RABC on high-quality data (2.2: 50% L2, 2.5: 80% L2). The 0% → 50–80% jump is as clean a signal as you'll find in a 20-rollout experiment. Level 2 is genuinely harder. It requires the policy to have seen consistent, high-quality demonstrations of the full task, because without a reliable starting state after unfolding, the subsequent folds can't succeed.
-
-#### 6. Speed and fold quality both track data quality
-
-Series 1 completes Level 1 in **78–122s**; Series 2 does it in **41–73s**. Fold quality (1–5 scale) hits a ceiling around 2.8 in Series 1, breaking past 3.0 only with high-quality data.
-
-| Experiment | Level 1 Time | Level 1 SR | Quality |
-|:---:|:---:|:---:|:---:|
-| 1.1 (π0, all data) | 121.5s | 80% | 2.70 |
-| 1.7 (best S1) | 99.5s | 80% | 2.30 |
-| 2.1 (HQ finetune)* | 57.6s | 70% | 2.80 |
-| 2.2 (HQ + RABC) | 43.2s | 100% | 3.30 |
-| 2.5 (best overall) | **40.8s** | **100%** | **4.10** |
-
-Policies trained on the full dataset learned hesitant motions; the high-quality dataset enforces deliberate and progress oriented actions. Faster completion isn't a separate goal from quality it's a consequence of a clear, unambiguous strategy.
-
-#### 8. What did not work
-
-**Mirroring augmentation** (2.3): only 5% total SR. Mirroring doubles multimodality, making convergence much harder even at 100k steps.

app/src/content/chapters/folding/09-learnings.mdx

@@ -1,5 +1,4 @@
 import Note from "../../../components/Note.astro";
-import Sidenote from "../../../components/Sidenote.astro";
 
 ## Learnings
 
@@ -12,7 +11,6 @@ Beyond the experiment findings above, several practical insights stood out:
 - **Train a reward model.** [SARM](https://huggingface.co/docs/lerobot/sarm) gave us data scoring, advantage conditioning, and curation in one package. We recommend it even for tasks where you think manual filtering would suffice.
 - **Invest in recording quality early.** More time upfront on clean and consistent recordings pays off more than extra volume.
 - **Record at higher frequency.** We'd record at 50 fps if we had to do it again. Folding is dynamic and higher record rates capture transitions better.
-- **DAgger is promising.** Corrections targeting the model's actual failure modes should be highly effective at pushing success rates higher. This infrastructure is ready and now also merged into LeRobot.
 
 ### For the community: the order of operations
 
@@ -50,17 +48,7 @@ lerobot-train \
     --policy.use_relative_actions=true
 ```
 
-7. **Use DAgger for targeted improvement.** Once you have a model that mostly works, collect correction data for its specific failure modes. LeRobot's [HIL scripts](https://github.com/huggingface/lerobot/tree/main/examples/hil) handle the full loop, the operator watches the policy run, pauses on failure, teleoperates a recovery, and hands control back:
-
-```bash
-python examples/hil/hil_data_collection.py \
-    --robot.type=bi_openarm_follower \
-    --teleop.type=openarm_mini \
-    --policy.path=outputs/pretrain/checkpoints/last/pretrained_model \
-    --dataset.repo_id=your-username/hil-dataset \
-    --rtc.enabled=true \
-    --rtc.execution_horizon=20
-```
+7. **Use [DAgger](https://github.com/huggingface/lerobot/tree/main/examples/hil) for targeted improvement.** Once you have a model that mostly works, collect correction data for its specific failure modes using LeRobot's Human-in-the-Loop scripts.
 
 8. **Film every evaluation.** Metrics alone won't tell the full story. Video reveals subtle failure modes that success rate misses, and lets you score quality.