RynnValue-4B temporal distance demo

.gitattributes

@@ -34,3 +34,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 examples/put_the_box_in_the_drawer_and_close_it.mp4 filter=lfs diff=lfs merge=lfs -text
+examples/so101_pink_lego_brick_into_box.mp4 filter=lfs diff=lfs merge=lfs -text

README.md

@@ -4,50 +4,36 @@ emoji: 🤖
 colorFrom: blue
 colorTo: indigo
 sdk: gradio
-sdk_version: 5.50.0
+sdk_version: 6.14.0
 app_file: app.py
-short_description: Predict remaining time to task completion in robot videos
 python_version: "3.12"
-startup_duration_timeout: 1h
 pinned: false
 license: apache-2.0
+short_description: Predict remaining time to task completion in robot videos
 models:
   - Alibaba-DAMO-Academy/RynnValue-4B
+startup_duration_timeout: 45m
 ---
 
 # RynnValue-4B
 
 Interactive demo of [Alibaba-DAMO-Academy/RynnValue-4B](https://huggingface.co/Alibaba-DAMO-Academy/RynnValue-4B),
-a Qwen3-VL-based value model for robot manipulation.
-
-Upload a manipulation video plus the task instruction and the model returns:
-
-- a **remaining-time curve** — for every prefix of the video, the predicted
-  minimum number of seconds until the task is complete — rendered alongside the
-  video and compared with the true remaining video time;
-- a short **analysis**: what the agent is doing, whether the video matches the
-  instruction, and whether the task was completed.
-
-## How it works
-
-The demo follows the authors' reference implementation
-([`rynn_infer/inference.py`](https://github.com/alibaba-damo-academy/RynnValue/blob/main/rynn_infer/inference.py)
-and `rynn_infer/plot_utils.py`):
-
-1. the video is decoded once into a uniformly spaced frame pool;
-2. prefix-uniform sampling — for each evaluated step `i`, `frames[0:i]` is
-   resampled to *N* frames and the **last** `<value>` prediction slot is read
-   out, so each score only conditions on frames seen so far;
-3. a final generation pass over the full video produces the `Analysis` block;
-4. the value curve is composited next to the video, mirroring `plot_utils.py`.
+a value foundation model for robot manipulation built on RynnBrain (Qwen3-VL).
 
-The custom `pred_slot_isolated_eager` attention shipped with the checkpoint is
-enabled explicitly, exactly as the reference CLI does.
+Give it a manipulation video plus the task instruction and it predicts the **temporal distance** —
+the remaining seconds until the task is complete — for a series of video prefixes, and generates a
+short analysis (video description, whether the video matches the instruction, whether it succeeded).
 
-Runs on ZeroGPU (bf16, ~10 GB of weights).
+The inference protocol mirrors the authors' reference script `rynn_infer/inference.py`
+(prefix-uniform sampling, last prediction slot read out per prefix, `pred_slot_isolated_eager`
+attention, one `generate()` pass for the Analysis block) and reproduces its side-by-side
+"video + value trend" rendering.
 
-## Example asset
+## Example assets
 
-`examples/put_the_box_in_the_drawer_and_close_it.mp4` is the official example
-clip from the [RynnValue repository](https://github.com/alibaba-damo-academy/RynnValue)
-(Apache-2.0), re-encoded to 640 px wide.
+- `examples/put_the_box_in_the_drawer_and_close_it.mp4` — the authors' own sample from
+  [github.com/alibaba-damo-academy/RynnValue](https://github.com/alibaba-damo-academy/RynnValue)
+  (`example/`), Apache-2.0, downscaled to 640×360.
+- `examples/so101_pink_lego_brick_into_box.mp4` — episode 0 (side camera) of
+  [lerobot/svla_so101_pickplace](https://huggingface.co/datasets/lerobot/svla_so101_pickplace),
+  Apache-2.0.

app.py

@@ -1,117 +1,161 @@
 """RynnValue-4B — robot-manipulation value model demo.
 
-Given a manipulation video and a task instruction, RynnValue predicts, for each
-prefix of the video, the *minimum remaining time (in seconds) until the task is
-complete*, plus a short textual analysis (description / instruction match /
-success).
-
-The inference path mirrors the official reference implementation
-(https://github.com/alibaba-damo-academy/RynnValue, `rynn_infer/inference.py`
-and `rynn_infer/plot_utils.py`, Apache-2.0): prefix-uniform sampling of the
-frames, one value read-out per prefix, and a synchronized trend plot rendered
-next to the video.
+Given a manipulation video and the task instruction, RynnValue predicts the
+*temporal distance* (remaining seconds until the task is done) for a sequence of
+video prefixes, plus a short natural-language analysis (description / does the
+video match the instruction / did it succeed).
+
+The inference path mirrors the authors' reference script
+(`rynn_infer/inference.py` in github.com/alibaba-damo-academy/RynnValue):
+prefix-uniform sampling — for each evaluated step `i` the prefix `frames[0:i+1]`
+is resampled to `num_frames` with `np.linspace` and the value of the *last*
+prediction slot is read out, so every score only conditions on frames seen so
+far — followed by one `generate()` pass on the full-video prefix for the
+Analysis block, and the same side-by-side "video + trend plot" rendering.
 """
 
 import os
 
 os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
 
-import spaces  # noqa: E402  — must precede any CUDA-touching import
+import spaces  # noqa: E402  (must precede torch/CUDA imports)
 
-import io  # noqa: E402
-import math  # noqa: E402
 import re  # noqa: E402
 import tempfile  # noqa: E402
 import time  # noqa: E402
-from typing import Any, Dict, List, Optional, Tuple  # noqa: E402
 
-import numpy as np  # noqa: E402
-import torch  # noqa: E402
 import gradio as gr  # noqa: E402
 import imageio.v2 as imageio  # noqa: E402
 import matplotlib  # noqa: E402
 
 matplotlib.use("Agg")
 import matplotlib.pyplot as plt  # noqa: E402
+import numpy as np  # noqa: E402
+import torch  # noqa: E402
 from PIL import Image, ImageDraw, ImageFont  # noqa: E402
 from transformers import AutoConfig, AutoModel, AutoProcessor  # noqa: E402
 
-# --------------------------------------------------------------------------- #
-# Model
-# --------------------------------------------------------------------------- #
-
 MODEL_ID = "Alibaba-DAMO-Academy/RynnValue-4B"
-DTYPE = torch.bfloat16
 
-_config = AutoConfig.from_pretrained(MODEL_ID, trust_remote_code=True)
-# The exported checkpoint doesn't persist the attention implementation, so force
-# the custom prediction-slot isolation attention (as the reference CLI does).
-_config._attn_implementation = "pred_slot_isolated_eager"
+# ---------------------------------------------------------------------------
+# Model
+# ---------------------------------------------------------------------------
+
+# The exported checkpoint bundles an older config that does not persist the
+# attention implementation, so force the custom prediction-slot isolation
+# attention exactly like the reference script does.
+config = AutoConfig.from_pretrained(MODEL_ID, trust_remote_code=True)
+config._attn_implementation = "pred_slot_isolated_eager"
 
 model = AutoModel.from_pretrained(
     MODEL_ID,
-    config=_config,
+    config=config,
     trust_remote_code=True,
-    torch_dtype=DTYPE,
+    torch_dtype=torch.bfloat16,
 )
-# The value heads are built in fp32 regardless of `torch_dtype`; the reference
-# CLI casts the whole model with `.to(device=..., dtype=...)`, so do the same or
-# the head matmuls hit "mat1 and mat2 must have the same dtype".
-model = model.eval().to(device="cuda", dtype=DTYPE)
+model = model.to(device="cuda", dtype=torch.bfloat16).eval()
 
 processor = AutoProcessor.from_pretrained(MODEL_ID, trust_remote_code=True)
 tokenizer = processor.tokenizer
 EOS_TOKEN_ID = tokenizer.convert_tokens_to_ids("<|im_end|>")
 
-# --------------------------------------------------------------------------- #
-# Defaults / limits
-# --------------------------------------------------------------------------- #
+# ---------------------------------------------------------------------------
+# Defaults
+# ---------------------------------------------------------------------------
 
-# Embodiment / camera phrasings taken from the authors' robometer constants
-# (robometer/robometer/configs/constants.py) so they stay in-distribution.
 DEFAULT_ROBOT = "a Franka single-arm robot"
 DEFAULT_CAMERA = "the main camera"
-
-DEFAULT_NUM_FRAMES = 16          # frames per prefix fed to the model
-DEFAULT_NUM_STEPS = 16           # prefixes evaluated along the video
-DEFAULT_MAX_SIDE = 448           # longest side of a model input frame
+DEFAULT_NUM_FRAMES = 32
+DEFAULT_NUM_STEPS = 24
+DEFAULT_MAX_IMAGE_SIDE = 384
 DEFAULT_MAX_NEW_TOKENS = 128
+BATCH_SIZE = 2
+
+MAX_DECODE_FRAMES = 900  # hard cap on decoded frames (memory guard)
+RENDER_MAX_SIDE = 640  # frames are downscaled to this for the rendered video
+
+ROBOT_CHOICES = [
+    "a Franka single-arm robot",
+    "a Franka dual-arm robot",
+    "an SO-101 single-arm robot",
+    "a Koch dual-arm robot",
+    "an xArm single-arm robot",
+    "a Trossen dual-arm robot",
+    "a UR5 single-arm robot",
+    "a human demonstrator",
+]
+CAMERA_CHOICES = [
+    "the main camera",
+    "the side camera",
+    "the top-down camera",
+    "the wrist-mounted camera",
+    "the main left camera",
+    "the main right camera",
+    "the egocentric camera",
+]
+
+# ---------------------------------------------------------------------------
+# Video I/O
+# ---------------------------------------------------------------------------
+
+
+def load_video_frames(video_path):
+    """Decode a video to RGB PIL frames, capped at MAX_DECODE_FRAMES.
+
+    Returns (frames, effective_fps). Long videos are decoded with a stride so
+    memory stays bounded; the effective fps is scaled to match, which keeps the
+    wall-clock timeline (and therefore the seconds axis) correct.
+    """
+    if not video_path or not os.path.isfile(video_path):
+        raise gr.Error("Please provide a video file.")
+
+    reader = imageio.get_reader(video_path)
+    meta = reader.get_meta_data()
+    fps = float(meta.get("fps") or 30.0)
+    if not np.isfinite(fps) or fps <= 0:
+        fps = 30.0
+    duration = meta.get("duration")
+    estimated = int(duration * fps) if duration and np.isfinite(duration) else None
+
+    stride = 1
+    if estimated and estimated > MAX_DECODE_FRAMES:
+        stride = int(np.ceil(estimated / MAX_DECODE_FRAMES))
+
+    frames = []
+    try:
+        for i, raw in enumerate(reader):
+            if i % stride:
+                continue
+            img = Image.fromarray(raw).convert("RGB")
+            w, h = img.size
+            if max(w, h) > RENDER_MAX_SIDE:
+                s = RENDER_MAX_SIDE / max(w, h)
+                img = img.resize((max(1, round(w * s)), max(1, round(h * s))), Image.BICUBIC)
+            frames.append(img)
+            if len(frames) >= MAX_DECODE_FRAMES:
+                break
+    finally:
+        reader.close()
 
-POOL_SIZE = 128                  # decoded frames kept as the model frame pool
-DISPLAY_MAX_SIDE = 640           # longest side of the rendered output video
-MAX_RENDER_FRAMES = 480          # cap on frames written to the output video
-MAX_DECODE_FRAMES = 3600         # hard cap on decoded frames (~2 min @ 30 fps)
-
-
-# --------------------------------------------------------------------------- #
-# Video helpers
-# --------------------------------------------------------------------------- #
-
-
-def _even(x: int) -> int:
-    x = int(round(x))
-    return x if x % 2 == 0 else x + 1
+    if not frames:
+        raise gr.Error(f"No frames could be decoded from {os.path.basename(video_path)}.")
+    return frames, fps / stride
 
 
-def _fit(size: Tuple[int, int], max_side: int) -> Tuple[int, int]:
-    w, h = size
+def resize_frames(frames, max_side):
+    """Downscale frames so the longer side is at most ``max_side``."""
+    if max_side <= 0:
+        return frames
+    w, h = frames[0].size
     if max(w, h) <= max_side:
-        return _even(w), _even(h)
-    scale = max_side / float(max(w, h))
-    return _even(w * scale), _even(h * scale)
-
-
-def _probe(video_path: str) -> Dict[str, Any]:
-    reader = imageio.get_reader(video_path, format="FFMPEG")
-    try:
-        meta = dict(reader.get_meta_data())
-    finally:
-        reader.close()
-    return meta
+        return frames
+    scale = max_side / max(w, h)
+    new_size = (max(1, round(w * scale)), max(1, round(h * scale)))
+    return [f.resize(new_size, resample=Image.BICUBIC) for f in frames]
 
 
-def sample_frame_indices(total: int, num_frames: int) -> List[int]:
-    """Uniformly pick ``num_frames`` indices from ``total`` frames (reference logic)."""
+def sample_frame_indices(total, num_frames):
+    """Uniformly pick ``num_frames`` indices out of ``total`` frames."""
     if num_frames <= 0 or num_frames >= total:
         return list(range(total))
     if num_frames == 1:
@@ -120,142 +164,62 @@ def sample_frame_indices(total: int, num_frames: int) -> List[int]:
     return [int(round(j * step)) for j in range(num_frames)]
 
 
-def build_frame_pool(video_path: str, max_image_side: int = DEFAULT_MAX_SIDE) -> Dict[str, Any]:
-    """Decode a video once and keep a uniformly-spaced pool of resized frames."""
-    if not video_path:
-        raise gr.Error("Please upload a video first.")
-
-    meta = _probe(video_path)
-    src_fps = float(meta.get("fps") or 30.0)
-    if not math.isfinite(src_fps) or src_fps <= 0:
-        src_fps = 30.0
-    src_size = tuple(meta.get("source_size") or meta.get("size") or (640, 480))
-    duration = float(meta.get("duration") or 0.0)
-    n_est = max(1, int(round(duration * src_fps)))
-
-    pool_px = _fit(src_size, int(max_image_side))
-    stride = max(1, math.ceil(n_est / POOL_SIZE))
-
-    frames: List[Image.Image] = []
-    kept: List[int] = []
-    last_frame = None
-    n_total = 0
-
-    reader = imageio.get_reader(video_path, format="FFMPEG", size=pool_px)
-    try:
-        for i, frame in enumerate(reader):
-            if i >= MAX_DECODE_FRAMES:
-                break
-            n_total = i + 1
-            last_frame = frame
-            if i % stride == 0:
-                frames.append(Image.fromarray(frame).convert("RGB"))
-                kept.append(i)
-    finally:
-        reader.close()
+# ---------------------------------------------------------------------------
+# Analysis parsing (same regexes as the reference script)
+# ---------------------------------------------------------------------------
 
-    if not frames:
-        raise gr.Error("Could not decode any frames from that video.")
+_DESCRIPTION_RE = re.compile(r"-\s*Video Description:\s*(.+)", re.IGNORECASE)
+_MATCH_RE = re.compile(r"-\s*Match:\s*(Yes|No)", re.IGNORECASE)
+_SUCCESS_RE = re.compile(r"-\s*Success:\s*(Yes|No)", re.IGNORECASE)
 
-    if kept[-1] != n_total - 1 and last_frame is not None:
-        frames.append(Image.fromarray(last_frame).convert("RGB"))
-        kept.append(n_total - 1)
 
-    if len(frames) > POOL_SIZE:
-        sel = np.linspace(0, len(frames) - 1, POOL_SIZE).astype(int)
-        frames = [frames[k] for k in sel]
-        kept = [int(kept[k]) for k in sel]
+def parse_analysis(text):
+    def _first(pattern):
+        m = pattern.search(text)
+        return m.group(1).strip() if m else None
 
     return {
-        "video_path": video_path,
-        "pool": frames,
-        "pool_idx": kept,
-        "n_total": int(n_total),
-        "src_fps": float(src_fps),
-        "src_size": (int(src_size[0]), int(src_size[1])),
+        "description": _first(_DESCRIPTION_RE),
+        "match": _first(_MATCH_RE),
+        "success": _first(_SUCCESS_RE),
     }
 
 
-def _nearest_pool_pos(pool_idx: np.ndarray, j: int) -> int:
-    p = int(np.searchsorted(pool_idx, j))
-    if p <= 0:
-        return 0
-    if p >= len(pool_idx):
-        return len(pool_idx) - 1
-    return p if abs(pool_idx[p] - j) < abs(pool_idx[p - 1] - j) else p - 1
-
+# ---------------------------------------------------------------------------
+# Trend plot + video rendering
+# ---------------------------------------------------------------------------
 
-# --------------------------------------------------------------------------- #
-# Trend rendering (adapted from rynn_infer/plot_utils.py, Apache-2.0)
-# --------------------------------------------------------------------------- #
 
+def _format_time(seconds):
+    minutes = int(seconds // 60)
+    secs = int(seconds % 60)
+    millis = int((seconds - int(seconds)) * 1000)
+    return f"{minutes:02d}:{secs:02d}.{millis:03d}"
 
-def _fig_to_pil(fig, size=None) -> Image.Image:
-    buf = io.BytesIO()
-    fig.savefig(buf, format="png")
-    buf.seek(0)
-    img = Image.open(buf).convert("RGB")
-    buf.close()
-    plt.close(fig)
-    if size is not None:
-        img = img.resize(size)
-    return img
 
+def _render_trend_frames(values, sampled_indices, fps, size, title, task_title):
+    """Render one plot image per prediction step.
 
-def _format_time(seconds: float) -> str:
-    minutes = int(seconds // 60)
-    seconds_int = int(seconds % 60)
-    millis = int((seconds - int(seconds)) * 1000)
-    return f"{minutes:02d}:{seconds_int:02d}.{millis:03d}"
-
-
-def _make_trend_plot(
-    value,
-    current_idx: int,
-    fps: float,
-    size=(400, 300),
-    title: str = "Remaining Time (s)",
-    task_title: Optional[str] = None,
-    baseline_label: str = "ground-truth remaining",
-    sampled_indices=None,
-) -> Image.Image:
+    The plot only changes at the sampled indices, so we render
+    ``len(values)`` images (a couple of dozen) and reuse them across the video
+    instead of re-rendering a figure for every frame.
+    """
     w, h = size
     dpi = 100
-    fig, ax1 = plt.subplots(figsize=(max(w / dpi, 1.0), max(h / dpi, 1.0)), dpi=dpi,
-                            constrained_layout=True)
-
-    small_mode = (w < 320 or h < 260)
-    medium_mode = (w < 420 or h < 320)
-    if small_mode:
-        title_fs, label_fs, tick_fs, legend_fs = 9, 8, 7, 7
-        line_w, marker_s1, marker_s2, show_legend = 1.5, 20, 16, False
-    elif medium_mode:
-        title_fs, label_fs, tick_fs, legend_fs = 10, 9, 8, 8
-        line_w, marker_s1, marker_s2, show_legend = 1.8, 24, 20, True
-    else:
-        title_fs, label_fs, tick_fs, legend_fs = 12, 10, 9, 9
-        line_w, marker_s1, marker_s2, show_legend = 2.0, 30, 25, True
-
-    if sampled_indices is not None:
-        x = np.asarray(sampled_indices, dtype=float)
-        total_frames = int(x[-1]) + 1
-        remaining_curve = (x[-1] - x) / float(fps)
-    else:
-        x = np.arange(len(value))
-        total_frames = len(value)
-        remaining_curve = (len(value) - 1 - np.arange(len(value))) / float(fps)
-    y = np.asarray(value, dtype=float)
-
-    ax1.plot(x[: current_idx + 1], y[: current_idx + 1], color="tab:blue",
-             linewidth=line_w, label="predicted")
-    ax1.scatter([x[current_idx]], [y[current_idx]], color="red", s=marker_s1,
-                zorder=3, label="current")
-    ax1.set_xlabel("Frame", fontsize=label_fs)
-    ax1.set_ylabel("Predicted (s)", color="tab:blue", fontsize=label_fs)
-    ax1.tick_params(axis="x", labelsize=tick_fs)
-    ax1.tick_params(axis="y", labelcolor="tab:blue", labelsize=tick_fs)
+    fig, ax1 = plt.subplots(figsize=(w / dpi, h / dpi), dpi=dpi, constrained_layout=True)
+
+    x = np.asarray(sampled_indices, dtype=float)
+    y = np.asarray(values, dtype=float)
+    remaining = (x[-1] - x) / float(fps)
+
+    (line,) = ax1.plot([], [], color="tab:blue", linewidth=2.0, label="predicted value")
+    pt1 = ax1.scatter([x[0]], [y[0]], color="red", s=30, zorder=3, label="current value")
+    ax1.set_xlabel("Frame", fontsize=9)
+    ax1.set_ylabel("Value", color="tab:blue", fontsize=9)
+    ax1.tick_params(axis="x", labelsize=8)
+    ax1.tick_params(axis="y", labelcolor="tab:blue", labelsize=8)
     ax1.grid(True, alpha=0.3)
-    ax1.set_xlim(0, max(total_frames - 1, 1))
+    ax1.set_xlim(0, max(float(x[-1]), 1.0))
 
     y_min, y_max = float(np.min(y)), float(np.max(y))
     if y_min == y_max:
@@ -265,255 +229,214 @@ def _make_trend_plot(
     ax1.set_ylim(y_min - margin, y_max + margin)
 
     ax2 = ax1.twinx()
-    ax2.plot(x, remaining_curve, color="green", linestyle="--", linewidth=line_w,
-             label=baseline_label)
-    ax2.scatter([x[current_idx]], [remaining_curve[current_idx]], color="green",
-                s=marker_s2, zorder=3)
-    ax2.set_ylabel("Remain (s)" if small_mode else "Video remaining (s)",
-                   color="green", fontsize=label_fs)
-    ax2.tick_params(axis="y", labelcolor="green", labelsize=tick_fs)
-
-    rt_min, rt_max = float(np.min(remaining_curve)), float(np.max(remaining_curve))
+    ax2.plot(x, remaining, color="green", linestyle="--", linewidth=2.0, label="remaining time")
+    pt2 = ax2.scatter(
+        [x[0]], [remaining[0]], color="green", s=25, zorder=3, label="current remaining"
+    )
+    ax2.set_ylabel("Remaining Time (s)", color="green", fontsize=9)
+    ax2.tick_params(axis="y", labelcolor="green", labelsize=8)
+    rt_min, rt_max = float(np.min(remaining)), float(np.max(remaining))
     if rt_min == rt_max:
         rt_min -= 1.0
         rt_max += 1.0
     rt_margin = 0.05 * (rt_max - rt_min)
     ax2.set_ylim(rt_min - rt_margin, rt_max + rt_margin)
 
-    if small_mode or task_title is None:
-        full_title = title
-    else:
-        short = task_title if len(task_title) <= 42 else task_title[:41] + "…"
-        full_title = f"{short}\n{title}"
-    ax1.set_title(full_title, fontsize=title_fs)
-
-    if show_legend:
-        lines1, labels1 = ax1.get_legend_handles_labels()
-        lines2, labels2 = ax2.get_legend_handles_labels()
-        ax1.legend(lines1 + lines2, labels1 + labels2, loc="best", fontsize=legend_fs)
-
-    return _fig_to_pil(fig, size=size)
+    short_task = task_title if len(task_title) <= 42 else task_title[:39] + "..."
+    ax1.set_title(f"{short_task}\n{title}", fontsize=10)
+
+    lines1, labels1 = ax1.get_legend_handles_labels()
+    lines2, labels2 = ax2.get_legend_handles_labels()
+    ax1.legend(lines1 + lines2, labels1 + labels2, loc="best", fontsize=7)
+
+    images = []
+    for i in range(len(y)):
+        line.set_data(x[: i + 1], y[: i + 1])
+        pt1.set_offsets(np.array([[x[i], y[i]]]))
+        pt2.set_offsets(np.array([[x[i], remaining[i]]]))
+        fig.canvas.draw()
+        buf = np.asarray(fig.canvas.buffer_rgba())[:, :, :3].copy()
+        images.append(Image.fromarray(buf))
+    plt.close(fig)
+    return images
 
 
-def _load_font(size: int):
+def _overlay_font(size):
     try:
         return ImageFont.load_default(size=size)
     except TypeError:  # Pillow < 10.1
         return ImageFont.load_default()
 
 
-def _draw_overlay_text(img: Image.Image, lines, font, xy=(10, 10), line_spacing=6) -> Image.Image:
+def _draw_overlay_text(img, lines, font):
+    img = img.copy()
     draw = ImageDraw.Draw(img)
-    x, y = xy
+    x, y = 8, 8
     for line in lines:
-        draw.text((x, y), line, fill=(255, 235, 60), font=font,
-                  stroke_width=2, stroke_fill=(0, 0, 0))
-        bbox = draw.textbbox((x, y), line, font=font, stroke_width=2)
-        y += (bbox[3] - bbox[1]) + line_spacing
+        draw.text(
+            (x, y), line, fill=(255, 235, 59), font=font, stroke_width=2, stroke_fill=(0, 0, 0)
+        )
+        bbox = draw.textbbox((x, y), line, font=font)
+        y += (bbox[3] - bbox[1]) + 8
     return img
 
 
-def _ceil_to_multiple(x: int, multiple: int) -> int:
-    return ((x + multiple - 1) // multiple) * multiple
+def _ceil_to_multiple(v, m):
+    return ((v + m - 1) // m) * m
 
 
-def render_trend_video(
-    state: Dict[str, Any],
-    values: List[float],
-    sampled_indices: List[int],
-    instruction: str,
-) -> str:
-    """Composite the source video with a synchronized value-trend plot."""
-    video_path = state["video_path"]
-    n_total = int(state["n_total"])
-    src_fps = float(state["src_fps"])
+def save_video_with_trend(frames, values, sampled_indices, fps, output_path, task_title):
+    """Side-by-side video: annotated frames + synchronized value trend plot."""
+    base_w, base_h = frames[0].size
+    if base_h < 260:
+        scale = 260.0 / base_h
+        base_w, base_h = int(round(base_w * scale)), 260
+        frames = [f.resize((base_w, base_h)) for f in frames]
 
-    disp_w, disp_h = _fit(state["src_size"], DISPLAY_MAX_SIDE)
-    base_h = max(disp_h, 240)
-    base_w = int(round(disp_w * base_h / disp_h)) if disp_h else disp_w
+    plot_w = int(min(520, max(300, base_w * 0.75)))
+    plot_h = max(260, base_h)
 
-    plot_w = max(260, min(int(base_w * 0.45), 520))
-    plot_h = max(240, base_h)
-
-    plots = [
-        _make_trend_plot(
-            values, k, src_fps, size=(plot_w, plot_h),
-            title="Remaining Time (s)", task_title=instruction,
-            sampled_indices=sampled_indices,
-        )
-        for k in range(len(values))
-    ]
-    if plot_h != base_h:
+    plots = _render_trend_frames(
+        values,
+        sampled_indices,
+        fps,
+        (plot_w, plot_h),
+        "Remaining Time (s)",
+        task_title,
+    )
+    if plots[0].height != base_h:
         plots = [p.resize((plot_w, base_h)) for p in plots]
 
-    sampled = np.asarray(sampled_indices)
-    stride = max(1, math.ceil(n_total / MAX_RENDER_FRAMES))
-    out_fps = max(4.0, src_fps / stride)
+    idx_to_pos = {idx: pos for pos, idx in enumerate(sampled_indices)}
+    n = len(frames)
+    remaining_all = (n - 1 - np.arange(n)) / float(fps)
 
+    font = _overlay_font(16)
     canvas_w = _ceil_to_multiple(base_w + plot_w, 16)
     canvas_h = _ceil_to_multiple(base_h, 16)
 
-    font = _load_font(18)
-    out_path = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False).name
-    writer = imageio.get_writer(out_path, fps=out_fps, codec="libx264",
-                               macro_block_size=16, quality=7)
-    reader = imageio.get_reader(video_path, format="FFMPEG", size=(disp_w, disp_h))
+    writer = imageio.get_writer(
+        output_path,
+        fps=max(1.0, float(fps)),
+        codec="libx264",
+        quality=7,
+        macro_block_size=None,
+        ffmpeg_params=["-pix_fmt", "yuv420p"],
+    )
     try:
-        for i, frame in enumerate(reader):
-            if i >= n_total:
-                break
-            if i % stride:
-                continue
-            img = Image.fromarray(frame).convert("RGB")
-            if img.size != (base_w, base_h):
-                img = img.resize((base_w, base_h))
-
-            k = max(0, int(np.searchsorted(sampled, i, side="right")) - 1)
-            remaining = (n_total - 1 - i) / src_fps
-            img = _draw_overlay_text(
+        pos = 0
+        short_task = task_title if len(task_title) <= 48 else task_title[:45] + "..."
+        for i, img in enumerate(frames):
+            if i in idx_to_pos:
+                pos = idx_to_pos[i]
+            left = _draw_overlay_text(
                 img,
                 [
-                    f"predicted remaining: {values[k]:.2f}s",
-                    f"video remaining: {_format_time(remaining)}",
+                    f"task: {short_task}",
+                    f"predicted remaining: {values[pos]:.2f}s",
+                    f"actual remaining: {_format_time(remaining_all[i])}",
                 ],
                 font,
             )
-
             canvas = Image.new("RGB", (canvas_w, canvas_h), (255, 255, 255))
-            canvas.paste(img, (0, 0))
-            canvas.paste(plots[k], (base_w, 0))
+            canvas.paste(left, (0, 0))
+            canvas.paste(plots[pos], (base_w, 0))
             writer.append_data(np.asarray(canvas))
     finally:
-        reader.close()
         writer.close()
-    return out_path
+    return output_path
 
 
-# --------------------------------------------------------------------------- #
+# ---------------------------------------------------------------------------
 # Inference
-# --------------------------------------------------------------------------- #
-
-_DESCRIPTION_RE = re.compile(r"-\s*Video Description:\s*(.+)", re.IGNORECASE)
-_MATCH_RE = re.compile(r"-\s*Match:\s*(Yes|No)", re.IGNORECASE)
-_SUCCESS_RE = re.compile(r"-\s*Success:\s*(Yes|No)", re.IGNORECASE)
-
-
-def parse_analysis(text: str) -> Dict[str, Optional[str]]:
-    def _first(pattern):
-        m = pattern.search(text)
-        return m.group(1).strip() if m else None
-
-    return {
-        "description": _first(_DESCRIPTION_RE),
-        "match": _first(_MATCH_RE),
-        "success": _first(_SUCCESS_RE),
-    }
-
-
-def _batch_size_for(num_frames: int, frame_px: Tuple[int, int]) -> int:
-    """Pick a batch size that keeps the eager attention matrices bounded."""
-    w, h = frame_px
-    tokens_per_frame = max(1, (w * h) // 1024)  # patch 16, merge 2
-    seq = num_frames * (tokens_per_frame + 24) + 160
-    # 32 heads x 4 bytes, ~3 GB transient budget for the attention weights.
-    budget = 3.0e9 / (128.0 * float(seq) ** 2)
-    return int(max(1, min(4, math.floor(budget))))
-
-
-def _estimate_duration(
-    state=None,
-    instruction: str = "",
-    robot_description: str = DEFAULT_ROBOT,
-    camera_description: str = DEFAULT_CAMERA,
-    num_frames: int = DEFAULT_NUM_FRAMES,
-    num_steps: int = DEFAULT_NUM_STEPS,
-    max_new_tokens: int = DEFAULT_MAX_NEW_TOKENS,
+# ---------------------------------------------------------------------------
+
+
+def _gpu_duration(
+    video=None,
+    instruction="",
+    robot_description=DEFAULT_ROBOT,
+    camera_description=DEFAULT_CAMERA,
+    num_frames=DEFAULT_NUM_FRAMES,
+    num_steps=DEFAULT_NUM_STEPS,
+    max_image_side=DEFAULT_MAX_IMAGE_SIDE,
+    max_new_tokens=DEFAULT_MAX_NEW_TOKENS,
     *args,
     **kwargs,
-) -> int:
+):
     try:
-        n_f, n_s = int(num_frames), int(num_steps)
-        n_t = int(max_new_tokens)
-    except Exception:
-        n_f, n_s, n_t = DEFAULT_NUM_FRAMES, DEFAULT_NUM_STEPS, DEFAULT_MAX_NEW_TOKENS
-    return int(min(240, 45 + 0.30 * n_f * n_s + 0.10 * n_t))
-
-
-@spaces.GPU(duration=_estimate_duration)
-def predict_values(
-    state: Dict[str, Any],
-    instruction: str,
-    robot_description: str = DEFAULT_ROBOT,
-    camera_description: str = DEFAULT_CAMERA,
-    num_frames: int = DEFAULT_NUM_FRAMES,
-    num_steps: int = DEFAULT_NUM_STEPS,
-    max_new_tokens: int = DEFAULT_MAX_NEW_TOKENS,
-) -> Tuple[Dict[str, Any], str, str]:
-    """Predict the remaining-time value curve and the analysis for a video.
-
-    Args:
-        state: decoded frame-pool produced by the preparation step.
-        instruction: the task the robot is supposed to accomplish.
-        robot_description: embodiment phrase for the prompt meta block.
-        camera_description: camera viewpoint phrase for the prompt meta block.
-        num_frames: frames uniformly resampled from each video prefix.
-        num_steps: number of prefixes evaluated along the video.
-        max_new_tokens: token budget for the generated Analysis block.
-
-    Returns:
-        A payload with the value curve, a markdown analysis, and a status line.
-    """
-    if not state:
-        raise gr.Error("Please upload a video first.")
+        nf = int(num_frames)
+        ns = int(num_steps)
+        side = int(max_image_side)
+    except (TypeError, ValueError):
+        nf, ns, side = DEFAULT_NUM_FRAMES, DEFAULT_NUM_STEPS, DEFAULT_MAX_IMAGE_SIDE
+    # base (load + render) + per prefix-forward cost, scaled by tokens per frame
+    work = ns * nf * (side / 384.0) ** 2
+    return int(min(300, 45 + 0.09 * work))
+
+
+@spaces.GPU(duration=_gpu_duration)
+def analyze(
+    video,
+    instruction,
+    robot_description=DEFAULT_ROBOT,
+    camera_description=DEFAULT_CAMERA,
+    num_frames=DEFAULT_NUM_FRAMES,
+    num_steps=DEFAULT_NUM_STEPS,
+    max_image_side=DEFAULT_MAX_IMAGE_SIDE,
+    max_new_tokens=DEFAULT_MAX_NEW_TOKENS,
+    progress=gr.Progress(),
+):
+    started = time.time()
     instruction = (instruction or "").strip()
     if not instruction:
-        raise gr.Error("Please enter a task instruction.")
+        raise gr.Error("Please describe the task the agent is supposed to perform.")
 
     robot_description = (robot_description or "").strip() or None
     camera_description = (camera_description or "").strip() or None
     if robot_description is None and camera_description is None:
+        # The checkpoint was trained with use_meta=True; the conversation
+        # builder refuses to build a prompt without at least one meta field.
         robot_description = DEFAULT_ROBOT
 
-    num_frames = int(max(2, min(32, int(num_frames))))
-    num_steps = int(max(4, min(32, int(num_steps))))
-    max_new_tokens = int(max(16, min(256, int(max_new_tokens))))
+    num_frames = int(num_frames)
+    num_steps = int(num_steps)
+    max_image_side = int(max_image_side)
+    max_new_tokens = int(max_new_tokens)
 
-    pool: List[Image.Image] = state["pool"]
-    pool_idx = np.asarray(state["pool_idx"])
-    n_total = int(state["n_total"])
-    device = torch.device("cuda")
+    progress(0.02, desc="Decoding video...")
+    frames, fps = load_video_frames(video)
+    total = len(frames)
+    model_images = resize_frames(frames, max_image_side)
 
-    t0 = time.perf_counter()
+    eval_indices = sample_frame_indices(total, min(num_steps, total))
 
-    # Prefix-uniform sampling (mirrors robometer's compute_episode_progress):
-    # for each evaluated step, frames[0:end] are resampled to `num_frames` and a
-    # single value (the last prediction slot) is read out, so each score only
-    # conditions on frames seen so far.
-    eval_indices = sample_frame_indices(n_total, num_steps)
-
-    def build_prefix_sample(end_idx: int):
-        wanted = np.linspace(0, end_idx, num_frames, dtype=int)
-        images = [pool[_nearest_pool_pos(pool_idx, int(j))] for j in wanted]
+    def build_prefix_sample(end_idx):
+        frame_idx = np.linspace(0, end_idx, num_frames, dtype=int)
+        prefix_images = [model_images[j] for j in frame_idx]
         return processor.process_episode(
             instruction=instruction,
-            images=images,
+            images=prefix_images,
             robot_description=robot_description,
             camera_description=camera_description,
         )
 
     def run_batch(samples):
-        batch = dict(
-            input_ids=torch.cat([s["input_ids"] for s in samples], dim=0).to(device).long(),
-            attention_mask=torch.cat([s["attention_mask"] for s in samples], dim=0).to(device).long(),
-            pixel_values=torch.cat(
-                [s["pixel_values"].flatten(0, 1) for s in samples], dim=0
-            ).to(device),
-            image_grid_thw=torch.cat(
-                [s["image_grid_thw"].flatten(0, 1) for s in samples], dim=0
-            ).to(device).long(),
+        """One forward pass over a batch of prefixes -> last-slot value each."""
+        batch_kwargs = dict(
+            input_ids=torch.cat([s["input_ids"] for s in samples], dim=0).to("cuda").long(),
+            attention_mask=torch.cat([s["attention_mask"] for s in samples], dim=0)
+            .to("cuda")
+            .long(),
+            pixel_values=torch.cat([s["pixel_values"].flatten(0, 1) for s in samples], dim=0)
+            .to("cuda")
+            .to(torch.bfloat16),
+            image_grid_thw=torch.cat([s["image_grid_thw"].flatten(0, 1) for s in samples], dim=0)
+            .to("cuda")
+            .long(),
         )
         with torch.inference_mode():
-            outputs = model(**batch)
+            outputs = model(**batch_kwargs)
         pred = outputs.value.pred_value
         if pred.dim() == 2 and pred.shape[0] == 1:
             pred = pred.reshape(len(samples), -1)
@@ -525,28 +448,30 @@ def predict_values(
             pred = pred[:, 0]
         return pred.float().reshape(-1).tolist()
 
-    batch_size = _batch_size_for(num_frames, pool[0].size)
-    values: List[float] = []
+    pred_value = []
     final_sample = None
-    pending = []
+    batch = []
     for step, end_idx in enumerate(eval_indices):
         sample = build_prefix_sample(end_idx)
-        if step == len(eval_indices) - 1:
+        if end_idx == eval_indices[-1]:
             final_sample = sample
-        pending.append(sample)
-        if len(pending) >= batch_size or step == len(eval_indices) - 1:
-            values.extend(run_batch(pending))
-            pending = []
-    t_value = time.perf_counter()
-
-    # Analysis pass over the final prefix (the whole video, uniformly sampled).
-    input_ids = final_sample["input_ids"].to(device).long()
+        batch.append(sample)
+        if len(batch) >= BATCH_SIZE or step == len(eval_indices) - 1:
+            pred_value.extend(run_batch(batch))
+            batch = []
+            progress(
+                0.05 + 0.75 * len(pred_value) / len(eval_indices),
+                desc=f"Value pass {len(pred_value)}/{len(eval_indices)}",
+            )
+
+    progress(0.82, desc="Generating analysis...")
+    input_ids = final_sample["input_ids"].to("cuda").long()
     with torch.inference_mode():
         gen_out = model.generate(
             input_ids=input_ids,
-            attention_mask=final_sample["attention_mask"].to(device).long(),
-            pixel_values=final_sample["pixel_values"].flatten(0, 1).to(device),
-            image_grid_thw=final_sample["image_grid_thw"].flatten(0, 1).to(device).long(),
+            attention_mask=final_sample["attention_mask"].to("cuda").long(),
+            pixel_values=final_sample["pixel_values"].flatten(0, 1).to("cuda").to(torch.bfloat16),
+            image_grid_thw=final_sample["image_grid_thw"].flatten(0, 1).to("cuda").long(),
             max_new_tokens=max_new_tokens,
             do_sample=False,
             num_beams=1,
@@ -554,190 +479,149 @@ def predict_values(
             pad_token_id=EOS_TOKEN_ID,
             use_cache=True,
         )
-    raw_text = tokenizer.decode(gen_out[0, input_ids.shape[1]:], skip_special_tokens=True)
-    analysis = parse_analysis(raw_text)
-    t_end = time.perf_counter()
-
-    print(
-        f"[timing] steps={len(eval_indices)} frames/prefix={num_frames} "
-        f"batch={batch_size} value={t_value - t0:.1f}s analysis={t_end - t_value:.1f}s "
-        f"total={t_end - t0:.1f}s",
-        flush=True,
-    )
+    analysis_text = tokenizer.decode(gen_out[0, input_ids.shape[1] :], skip_special_tokens=True)
+    analysis = parse_analysis(analysis_text)
+    gpu_seconds = time.time() - started
 
-    def _flag(v):
+    progress(0.88, desc="Rendering trend video...")
+    out_path = os.path.join(tempfile.mkdtemp(), "rynnvalue_trend.mp4")
+    save_video_with_trend(frames, pred_value, eval_indices, fps, out_path, instruction)
+
+    def _verdict(v):
         if v is None:
             return "—"
         return "✅ Yes" if v.lower() == "yes" else "❌ No"
 
-    md = "\n".join(
+    description = analysis["description"] or (analysis_text.strip() or "—")
+    summary = "\n".join(
         [
-            f"**Predicted remaining time at the first frame:** `{values[0]:.2f} s`  ",
-            f"**Predicted remaining time at the last frame:** `{values[-1]:.2f} s`  ",
-            f"**Actual video length:** `{(n_total - 1) / float(state['src_fps']):.2f} s`",
+            f"**Task instruction** — {instruction}",
+            "",
+            f"**Video description** — {description}",
             "",
-            f"**Video description:** {analysis['description'] or '—'}",
+            f"**Matches the instruction?** {_verdict(analysis['match'])} &nbsp;&nbsp;·&nbsp;&nbsp; "
+            f"**Task completed?** {_verdict(analysis['success'])}",
             "",
-            f"**Matches the instruction:** {_flag(analysis['match'])}",
+            f"**Predicted remaining time** — {pred_value[0]:.2f} s at the first frame → "
+            f"{pred_value[-1]:.2f} s at the last frame "
+            f"(video is {(total - 1) / fps:.1f} s long, {total} frames decoded).",
             "",
-            f"**Task completed:** {_flag(analysis['success'])}",
+            f"<sub>{len(eval_indices)} prefix evaluations · {num_frames} frames per prefix · "
+            f"{gpu_seconds:.1f} s on GPU</sub>",
         ]
     )
+    return out_path, summary
 
-    payload = {"values": values, "eval_indices": eval_indices, "raw": raw_text}
-    status = (
-        f"Scored {len(eval_indices)} prefixes ({num_frames} frames each) in "
-        f"{t_end - t0:.1f}s — rendering the trend video…"
-    )
-    return payload, md, status
-
-
-# --------------------------------------------------------------------------- #
-# Gradio handlers
-# --------------------------------------------------------------------------- #
-
-
-def prepare_video(video_path: str, max_image_side: int = DEFAULT_MAX_SIDE):
-    """Decode the uploaded video into a frame pool for the model."""
-    state = build_frame_pool(video_path, int(max_image_side))
-    status = (
-        f"Decoded {state['n_total']} frames @ {state['src_fps']:.1f} fps "
-        f"({(state['n_total'] - 1) / state['src_fps']:.1f}s) — running RynnValue…"
-    )
-    return state, status
 
-
-def render_result(state: Dict[str, Any], payload: Dict[str, Any], instruction: str):
-    """Render the annotated video with the synchronized value curve."""
-    t0 = time.perf_counter()
-    path = render_trend_video(state, payload["values"], payload["eval_indices"], instruction)
-    print(f"[timing] render={time.perf_counter() - t0:.1f}s", flush=True)
-    return path, "Done."
-
-
-def run_all(video: str, instruction: str):
-    """Analyse a robot manipulation video against a task instruction.
-
-    Args:
-        video: path to the manipulation video.
-        instruction: the task the robot is supposed to accomplish.
-
-    Returns:
-        The annotated video with the remaining-time curve, and the text analysis.
-    """
-    state, _ = prepare_video(video, DEFAULT_MAX_SIDE)
-    payload, md, _ = predict_values(
-        state,
-        instruction,
-        DEFAULT_ROBOT,
-        DEFAULT_CAMERA,
-        DEFAULT_NUM_FRAMES,
-        DEFAULT_NUM_STEPS,
-        DEFAULT_MAX_NEW_TOKENS,
-    )
-    path, _ = render_result(state, payload, instruction)
-    return path, md
-
-
-# --------------------------------------------------------------------------- #
+# ---------------------------------------------------------------------------
 # UI
-# --------------------------------------------------------------------------- #
-
-CSS = """
-#col-container { max-width: 1180px; margin: 0 auto; }
-.dark .gradio-container { color: var(--body-text-color); }
-"""
+# ---------------------------------------------------------------------------
 
-INTRO = """# RynnValue-4B — how much longer until the robot is done?
+DESCRIPTION = """
+<div align="center">
 
-[RynnValue](https://huggingface.co/Alibaba-DAMO-Academy/RynnValue-4B) is a
-vision-language value model for robot manipulation. Given a video and a task
-instruction it predicts the **minimum remaining time until the task is complete**
-for every point in the video, and writes a short analysis of what it sees.
+# 🤖 RynnValue-4B — how much longer until the robot is done?
 
-[model](https://huggingface.co/Alibaba-DAMO-Academy/RynnValue-4B) ·
-[code](https://github.com/alibaba-damo-academy/RynnValue) ·
-[project page](https://alibaba-damo-academy.github.io/RynnValue.github.io/)
-"""
-
-EXAMPLE_VIDEO = "examples/put_the_box_in_the_drawer_and_close_it.mp4"
+[Model](https://huggingface.co/Alibaba-DAMO-Academy/RynnValue-4B) ·
+[Paper](https://arxiv.org/abs/2608.09853) ·
+[GitHub](https://github.com/alibaba-damo-academy/RynnValue) ·
+[Project page](https://alibaba-damo-academy.github.io/RynnValue.github.io/)
 
-with gr.Blocks(theme=gr.themes.Citrus(), css=CSS, title="RynnValue-4B") as demo:
-    state = gr.State()
-    payload_state = gr.State()
+</div>
 
-    with gr.Column(elem_id="col-container"):
-        gr.Markdown(INTRO)
+**RynnValue** is a value foundation model for robot manipulation, built on RynnBrain (Qwen3-VL).
+Given a manipulation video *and* a task instruction, it predicts the **temporal distance** —
+the remaining time in seconds until the task is complete — for a series of video prefixes, and
+generates a short analysis: what the video shows, whether it **matches** the instruction, and
+whether the task **succeeded**.
 
-        with gr.Row():
-            with gr.Column(scale=1):
-                video_in = gr.Video(label="Manipulation video", height=300)
-                instruction_in = gr.Textbox(
-                    label="Task instruction",
-                    placeholder="Put the box in the drawer and close it",
-                    lines=2,
-                )
-                run_btn = gr.Button("Analyse", variant="primary")
-            with gr.Column(scale=1):
-                video_out = gr.Video(label="Value curve", height=300, autoplay=True)
-                analysis_out = gr.Markdown(label="Analysis")
+The output video plays the clip next to the predicted value curve (blue) alongside the actual
+remaining time of the clip (dashed green).
+"""
 
-        status_out = gr.Markdown("")
+with gr.Blocks(theme=gr.themes.Citrus(), title="RynnValue-4B") as demo:
+    gr.Markdown(DESCRIPTION)
 
-        with gr.Accordion("Advanced settings", open=False):
-            with gr.Row():
-                robot_in = gr.Textbox(label="Robot description", value=DEFAULT_ROBOT)
-                camera_in = gr.Textbox(label="Camera description", value=DEFAULT_CAMERA)
-            with gr.Row():
-                frames_in = gr.Slider(4, 32, value=DEFAULT_NUM_FRAMES, step=2,
-                                      label="Frames per prefix")
-                steps_in = gr.Slider(4, 32, value=DEFAULT_NUM_STEPS, step=1,
-                                     label="Prefixes evaluated (curve resolution)")
+    with gr.Row():
+        with gr.Column(scale=1):
+            video_in = gr.Video(label="Manipulation video", sources=["upload"], height=320)
+            instruction = gr.Textbox(
+                label="Task instruction",
+                placeholder="Put the box in the drawer and close it",
+                lines=2,
+            )
+            run_btn = gr.Button("Predict temporal distance", variant="primary")
             with gr.Row():
-                side_in = gr.Slider(320, 640, value=DEFAULT_MAX_SIDE, step=64,
-                                    label="Max frame side (px)")
-                tokens_in = gr.Slider(32, 256, value=DEFAULT_MAX_NEW_TOKENS, step=16,
-                                      label="Max new tokens (analysis)")
-
-        gr.Examples(
-            examples=[
-                [EXAMPLE_VIDEO, "Put the box in the drawer and close it"],
-                [EXAMPLE_VIDEO, "Pick up the apple and put it on the plate"],
-            ],
-            inputs=[video_in, instruction_in],
-            outputs=[video_out, analysis_out],
-            fn=run_all,
-            cache_examples=True,
-            cache_mode="lazy",
-            label="Examples (the second one deliberately mismatches the video)",
+                robot_desc = gr.Dropdown(
+                    label="Embodiment",
+                    choices=ROBOT_CHOICES,
+                    value=DEFAULT_ROBOT,
+                    allow_custom_value=True,
+                )
+                camera_desc = gr.Dropdown(
+                    label="Camera viewpoint",
+                    choices=CAMERA_CHOICES,
+                    value=DEFAULT_CAMERA,
+                    allow_custom_value=True,
+                )
+        with gr.Column(scale=1):
+            video_out = gr.Video(label="Value trend", height=360, autoplay=True)
+            analysis_md = gr.Markdown(label="Analysis")
+
+    with gr.Accordion("Advanced options", open=False):
+        gr.Markdown(
+            "The model is queried once per curve point, on the prefix of the video seen so far "
+            "(the authors' `rynn_infer/inference.py` protocol). More curve points and more frames "
+            "per prefix mean a smoother, better-conditioned curve — and a longer run."
+        )
+        num_frames = gr.Slider(
+            8, 64, value=DEFAULT_NUM_FRAMES, step=8, label="Frames per prefix (context length)"
+        )
+        num_steps = gr.Slider(
+            8, 48, value=DEFAULT_NUM_STEPS, step=4, label="Curve points (prefix evaluations)"
+        )
+        max_image_side = gr.Slider(
+            256, 640, value=DEFAULT_MAX_IMAGE_SIDE, step=64, label="Max frame side fed to the model"
+        )
+        max_new_tokens = gr.Slider(
+            32, 256, value=DEFAULT_MAX_NEW_TOKENS, step=32, label="Analysis token budget"
         )
 
-        # Single-call entry point for the API / MCP clients (the UI uses the
-        # three-step chain below so that only the model pass holds the GPU).
-        api_btn = gr.Button("analyze", visible=False)
-
-    run_btn.click(
-        prepare_video,
-        inputs=[video_in, side_in],
-        outputs=[state, status_out],
-        api_name=False,
-    ).then(
-        predict_values,
-        inputs=[state, instruction_in, robot_in, camera_in, frames_in, steps_in, tokens_in],
-        outputs=[payload_state, analysis_out, status_out],
-        api_name=False,
-    ).then(
-        render_result,
-        inputs=[state, payload_state, instruction_in],
-        outputs=[video_out, status_out],
-        api_name=False,
-    )
+    inputs = [
+        video_in,
+        instruction,
+        robot_desc,
+        camera_desc,
+        num_frames,
+        num_steps,
+        max_image_side,
+        max_new_tokens,
+    ]
+    outputs = [video_out, analysis_md]
+
+    run_btn.click(fn=analyze, inputs=inputs, outputs=outputs)
 
-    api_btn.click(
-        run_all,
-        inputs=[video_in, instruction_in],
-        outputs=[video_out, analysis_out],
-        api_name="analyze",
+    gr.Examples(
+        examples=[
+            [
+                "examples/put_the_box_in_the_drawer_and_close_it.mp4",
+                "Put the box in the drawer and close it",
+                "a Franka single-arm robot",
+                "the main camera",
+            ],
+            [
+                "examples/so101_pink_lego_brick_into_box.mp4",
+                "Put the pink lego brick into the transparent box",
+                "an SO-101 single-arm robot",
+                "the side camera",
+            ],
+        ],
+        inputs=[video_in, instruction, robot_desc, camera_desc],
+        outputs=outputs,
+        fn=analyze,
+        cache_examples=True,
+        cache_mode="lazy",
+        label="Examples",
     )
 
 if __name__ == "__main__":

examples/put_the_box_in_the_drawer_and_close_it.mp4

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a364c348ca4bbf172c68c923c412d2a161b484442e0635881676776fe7a46dfb
-size 1536090
+oid sha256:8fe70130284147c403115b2c477fa6d2e453396d807a12bd9838c27e0bf5fe06
+size 1167523

examples/so101_pink_lego_brick_into_box.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5b7e6b10aed77ee1324b8256717606c394b194ebf0c78149f650cdef08c2a2fd
+size 275446

requirements.txt

@@ -1,9 +1,13 @@
+torch==2.11.0
+torchvision
+# RynnValue's remote code targets the Qwen3-VL internals of the 4.57 line
+# (`Qwen3VLProcessorKwargs`, `ALL_MASK_ATTENTION_FUNCTIONS._global_mapping`,
+# `TransformersKwargs`); the model card pins `transformers>=4.57.0,<5`.
 transformers==4.57.6
 accelerate
-torchvision
 einops
 numpy
 pillow
-matplotlib
 imageio
 imageio-ffmpeg
+matplotlib