Restore working harness app (SFT prompt, per-step GPU requests); add bird example

README.md

@@ -6,26 +6,26 @@ colorTo: pink
 sdk: gradio
 sdk_version: 6.31.0
 app_file: app.py
-short_description: Agent writes Blender code to build a draft video
+short_description: Agent writes Blender code to build a 3D draft video
 python_version: "3.12"
 startup_duration_timeout: 1h
 license: apache-2.0
 models:
   - Video-Coder/Video-Coder-9B
-  - MiniMaxAI/MiniMax-H3
 ---
 
-# Video-Coder: Reinforcing Agentic Coding for Video Generation
+# Video-Coder
 
-Demo of [Video-Coder-9B](https://huggingface.co/Video-Coder/Video-Coder-9B) ([paper](https://huggingface.co/papers/2611.09894),
-[code](https://github.com/CYWang735/Video-Coder)). The agent runs in a port of the authors' **Video-Coder Harness**:
-it writes a Blender 4.5 Python script for your scene description, checks and renders it with `check_script` /
-`run_blender` (bpy 4.5.14, Workbench, Mesa llvmpipe on CPU), inspects the rendered frames, revises, and submits. The
-submitted script is re-rendered from scratch and becomes the **draft video**.
+Demo of [Video-Coder: Reinforcing Agentic Coding for Video Generation](https://huggingface.co/papers/2611.09894)
+([code](https://github.com/CYWang735/Video-Coder), [model](https://huggingface.co/Video-Coder/Video-Coder-9B)).
 
-Optional stage 2 sends the draft to MiniMax-H3 Ref2VA with the authors' white-model prompt template through the public
-[multimodalart/minimax-h3-reference](https://huggingface.co/spaces/multimodalart/minimax-h3-reference) Space (H3 is
-~196 GB in bf16, too large to live in this Space alongside the agent).
+**Video-Coder-9B** runs inside a port of the authors' *Video-Coder Harness*: it writes a Blender 4.5 Python script
+for the scene description, renders it (`run_blender`, bpy 4.5.14 / Workbench on CPU), looks at the rendered frames,
+fixes problems and submits. The output is the **draft video** (white-model render with the scene's layout, motion and
+camera).
 
-`harness/` contains code copied from the Video-Coder repository (Apache-2.0). Example prompts are the authors' own
-qualitative examples from the project page.
+The paper then turns the draft video into a final video with MiniMax-H3 (Ref2VA). That ~33B audio-video generator
+(plus its large text encoder) does not fit alongside the agent in this Space, so this demo stops at the draft video.
+
+The harness code in `harness/` is taken from the Video-Coder repository (`Video-Coder-RL/uni-agent`, Apache-2.0).
+Example prompts are from the Video-Coder project page and repository.

app.py

@@ -1,27 +1,19 @@
-"""Video-Coder: an agent that writes Blender code to build a draft video (Video-Coder-9B + the Video-Coder Harness).
-
-Port of the authors' inference path (examples/video_coder in https://github.com/CYWang735/Video-Coder):
-  * same system / instance prompts, tool (`bash`), observation and format-error templates (harness/teacher.yaml),
-  * same `check_script` / `run_blender` tools (copied harness code: bpy 4.5.14, Workbench on Mesa llvmpipe, CPU),
-    with visual feedback on (the rendered frames go back to the model as images), as in their inference config,
-  * same sampling (temperature 1.0, top_p 0.95) and acceptance (submit + static check + fresh re-render).
-The policy runs with transformers on ZeroGPU, one GPU call per agent turn; Blender runs on the CPU in between.
-Stage 2 (optional) sends the draft to MiniMax-H3 Ref2VA with the authors' prompt template through a public Space.
-"""
-
 import os
 
 os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
 
-import spaces  # noqa: E402  (before torch)
+import spaces  # noqa: E402  (must come before torch)
 
+import base64  # noqa: E402
 import difflib  # noqa: E402
+import hashlib  # noqa: E402
+import io  # noqa: E402
 import json  # noqa: E402
 import re  # noqa: E402
 import shutil  # noqa: E402
+import signal  # noqa: E402
 import subprocess  # noqa: E402
 import sys  # noqa: E402
-import sysconfig  # noqa: E402
 import tempfile  # noqa: E402
 import threading  # noqa: E402
 import time  # noqa: E402
@@ -30,64 +22,90 @@ from pathlib import Path  # noqa: E402
 
 import gradio as gr  # noqa: E402
 import torch  # noqa: E402
-import yaml  # noqa: E402
 from jinja2 import StrictUndefined, Template  # noqa: E402
+from PIL import Image  # noqa: E402
 from transformers import AutoModelForImageTextToText, AutoProcessor, TextIteratorStreamer  # noqa: E402
 
-APP_DIR = Path(__file__).resolve().parent
-HARNESS_ROOT = APP_DIR / "harness"
+ROOT = Path(__file__).resolve().parent
+HARNESS_ROOT = ROOT / "harness"
 sys.path.insert(0, str(HARNESS_ROOT))
-
-from guard import _normalize_output, harness_violation  # noqa: E402
-from video_coder_harness.blender_exec import execute  # noqa: E402
+for _tool in (HARNESS_ROOT / "bin").iterdir():  # the Hub does not keep the executable bit
+    _tool.chmod(0o755)
+
+from video_coder_harness.blender_exec import execute as blender_execute  # noqa: E402
+from video_coder_harness.guard import (  # noqa: E402
+    BLOCKED,
+    REPEAT_WARNING,
+    _normalize_output,
+    harness_violation,
+)
 from video_coder_harness.static_check import check_file  # noqa: E402
 
 MODEL_ID = "Video-Coder/Video-Coder-9B"
-H3_SPACE = os.environ.get("H3_SPACE", "multimodalart/minimax-h3-reference")
-RUNS_DIR = Path(tempfile.gettempdir()) / "video_coder_runs"
-RUNS_DIR.mkdir(parents=True, exist_ok=True)
 
 # --------------------------------------------------------------------------------------------------------------------
-# Blender: bpy 4.5.14 needs Python 3.11, the Space runs 3.12 -> a separate uv-managed 3.11 env, as in the harness
-# (`bpy_python` is its own interpreter there too).
+# Blender 4.5 (bpy 4.5.14 on Python 3.11, same as the authors' bpy-agent.sif sandbox), rendered on CPU with Mesa
+# llvmpipe. Installed into its own venv at startup because the Space itself runs Python 3.12.
 # --------------------------------------------------------------------------------------------------------------------
-BPY_ENV = Path(os.environ.get("BPY_ENV", str(Path.home() / "bpy45")))
-BPY_PYTHON = BPY_ENV / "bin" / "python"
+BPY_ENV = Path(os.environ.get("BPY_ENV", str(Path.home() / "bpyenv")))
+BPY_PY = BPY_ENV / "bin" / "python"
 
 
 def setup_bpy() -> None:
-    if BPY_PYTHON.exists() and subprocess.run([str(BPY_PYTHON), "-c", "import bpy"], capture_output=True).returncode == 0:
-        return
-    uv = shutil.which("uv") or os.path.join(sysconfig.get_path("scripts"), "uv")
+    if BPY_PY.exists():
+        r = subprocess.run([str(BPY_PY), "-c", "import bpy; print(bpy.app.version_string)"],
+                           capture_output=True, text=True)
+        if r.returncode == 0:
+            print("bpy ready:", r.stdout.strip())
+            return
     t0 = time.time()
-    subprocess.run([uv, "venv", "-q", "-p", "3.11", str(BPY_ENV)], check=True)
-    subprocess.run([uv, "pip", "install", "-q", "--python", str(BPY_PYTHON), "bpy==4.5.14"], check=True)
-    print(f"[bpy] installed bpy 4.5.14 in {time.time() - t0:.0f}s", flush=True)
+    subprocess.run([sys.executable, "-m", "uv", "venv", "-q", "-p", "3.11", "--clear", str(BPY_ENV)], check=True)
+    subprocess.run([sys.executable, "-m", "uv", "pip", "install", "-q", "-p", str(BPY_PY), "bpy==4.5.14"],
+                   check=True)
+    r = subprocess.run([str(BPY_PY), "-c", "import bpy; print(bpy.app.version_string)"],
+                       capture_output=True, text=True)
+    print(f"bpy install took {time.time() - t0:.0f}s:", r.stdout.strip(), r.stderr[-2000:])
 
 
 setup_bpy()
 
-_cfg = yaml.safe_load((HARNESS_ROOT / "teacher.yaml").read_text())
-# Overlay of the authors' inference config (configs/uni_container_visual.yaml): system Mesa, visual feedback on.
-HARNESS = {**_cfg["harness"], "bpy_python": str(BPY_PYTHON), "bpy_libs": "/usr", "visual_feedback": True}
-AGENT_CFG = _cfg["agent"]
-MODEL_CFG = _cfg["model"]
-ENV_CFG = _cfg["environment"]
-SUBMIT = "COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT"
-TEMPLATE_VARS = {
-    "blender_version": HARNESS["blender_version"],
-    "blender_available": HARNESS["blender_available"],
-    "fps": HARNESS["fps"],
-    "frame_count": HARNESS["frame_count"],
-    "max_frame_count": HARNESS.get("max_frame_count", HARNESS["frame_count"]),
-    "resolution": HARNESS["resolution"],
-    "script_name": HARNESS["script_name"],
-    "output_video": HARNESS["output_video"],
+# Harness settings: configs/teacher.yaml + configs/uni_container_visual.yaml (the RL / inference setting).
+HARNESS = {
+    "blender_version": "4.5",
+    "blender_available": True,
+    "bpy_python": str(BPY_PY),
+    "bpy_libs": "/usr",
+    "exec_timeout": 600,
+    "summary_samples": 6,
+    "content_samples": 8,
     "visual_feedback": True,
-    "preview_frames": HARNESS.get("preview_frames", 8),
-    "judge_enabled": False,
+    "preview_frames": 8,
+    "preview_width": 640,
+    "judge": {"enabled": False},
+    "output_video": "output.mp4",
+    "fps": 24,
+    "frame_count": 120,
+    "max_frame_count": 240,
+    "resolution": [1280, 720],
+    "script_name": "main.py",
 }
-BASH_TOOL = {  # mini-swe-agent's tool definition (minisweagent.models.utils.actions_toolcall.BASH_TOOL)
+SCRIPT = HARNESS["script_name"]
+CMD_TIMEOUT = 900
+REPEAT_WARN, REPEAT_STOP, REPEAT_SIM = 3, 6, 0.9
+MAX_FORMAT_ERRORS = 3
+RUNS_DIR = Path(tempfile.gettempdir()) / "video_coder_runs"
+RUNS_DIR.mkdir(parents=True, exist_ok=True)
+_SECRET_ENV = re.compile(r"(KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL)", re.I)
+HARNESS_MARKERS = [str(HARNESS_ROOT), str(BPY_ENV)]
+
+SYSTEM_PROMPT = (
+    "You are an expert Blender technical artist and Python programmer. You write Blender Python (bpy) scripts that "
+    "build and animate 3D scenes and render them as untextured white-model (clay) videos. You work in a Linux shell "
+    "through a bash tool."
+)
+# The exact user prompt of the SFT trajectories (Video-Coder/Train-Data sft_data.json), with the scene as __TASK__.
+INSTANCE_TEMPLATE = (HARNESS_ROOT / "instance_template.txt").read_text()
+TOOLS = [{
     "type": "function",
     "function": {
         "name": "bash",
@@ -98,422 +116,509 @@ BASH_TOOL = {  # mini-swe-agent's tool definition (minisweagent.models.utils.act
             "required": ["command"],
         },
     },
+}]
+OBSERVATION_TEMPLATE = Template("""{%- if output.output | length < 10000 -%}
+{
+  "returncode": {{ output.returncode }},
+  "output": {{ output.output | tojson }}
+  {%- if output.exception_info %}, "exception_info": {{ output.exception_info | tojson }}{% endif %}
 }
-_SECRET_ENV = re.compile(r"(KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL)", re.I)
-_TAG = re.compile(r"<MSWEA_MULTIMODAL_CONTENT><CONTENT_TYPE>(.+?)</CONTENT_TYPE>(.+?)</MSWEA_MULTIMODAL_CONTENT>", re.S)
-GUARD_MARKERS = [str(HARNESS_ROOT), str(BPY_ENV)]
-
-
-def render_template(name_or_text: str, **kw) -> str:
-    return Template(name_or_text, undefined=StrictUndefined).render(**kw)
-
-
-def preflight() -> None:
-    """The harness' own Blender preflight (10% resolution): fails loudly in the logs if bpy/Mesa cannot render."""
-    from video_coder_harness import blender_exec  # noqa: F401
-
-    script = """import bpy, os
-s = bpy.context.scene
-s.frame_start, s.frame_end = 1, {frames}
-s.render.engine = 'BLENDER_WORKBENCH'
-s.render.resolution_x, s.render.resolution_y, s.render.resolution_percentage = {w}, {h}, 10
-s.render.fps = {fps}
-cube = bpy.data.objects['Cube']
-cube.location = (0, 0, 0); cube.keyframe_insert('location', frame=1)
-cube.location = (2, 0, 0); cube.keyframe_insert('location', frame={frames})
-s.render.image_settings.file_format = 'FFMPEG'
-s.render.ffmpeg.format = 'MPEG4'
-s.render.ffmpeg.codec = 'H264'
-s.render.filepath = os.path.join(os.getcwd(), '{out}')
-bpy.ops.render.render(animation=True)
-"""
-    w, h = HARNESS["resolution"]
-    with tempfile.TemporaryDirectory() as tmp:
-        p = Path(tmp) / "preflight.py"
-        p.write_text(script.format(frames=HARNESS["frame_count"], w=w, h=h, fps=HARNESS["fps"], out=HARNESS["output_video"]))
-        r = execute(p, tmp, dict(HARNESS, resolution=[w // 10, h // 10]), preview=False)
-    print(f"[bpy] preflight ok={r['ok']} in {r['seconds']}s (cpus={os.cpu_count()}) problems={r['problems']} "
-          f"error={r.get('error')} tb={r.get('traceback')} log={r.get('log_tail')}", flush=True)
-
-
-preflight()
+{%- else -%}
+{
+  "returncode": {{ output.returncode }},
+  "output_head": {{ output.output[:5000] | tojson }},
+  "output_tail": {{ output.output[-5000:] | tojson }},
+  "elided_chars": {{ output.output | length - 10000 }},
+  "warning": "Output too long."
+  {%- if output.exception_info %}, "exception_info": {{ output.exception_info | tojson }}{% endif %}
+}
+{%- endif -%}
+""", undefined=StrictUndefined)
+FORMAT_ERROR_TEMPLATE = Template("""{% if finish_reason is defined and (finish_reason == "length" or (finish_reason == "tool_calls" and not has_tool_calls)) -%}
+Your previous response reached the output token limit (finish_reason={{ finish_reason }}) before you produced a tool call, so it was cut off. Respond more concisely and finish with exactly one bash tool call.
+{%- else -%}
+Tool call error:
+
+<error>
+{{error}}
+</error>
+
+Every response must call the 'bash' tool exactly once with {"command": "..."}.
+To finish, run `echo COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT` on its own.
+{%- endif %}
+""")
+MM_TAG = re.compile(r"(?s)<MSWEA_MULTIMODAL_CONTENT><CONTENT_TYPE>(.+?)</CONTENT_TYPE>(.+?)</MSWEA_MULTIMODAL_CONTENT>")
+TOOL_CALL_RE = re.compile(r"<tool_call>\s*<function=([^>\s]+)>(.*?)</function>\s*</tool_call>", re.S)
+PARAM_RE = re.compile(r"<parameter=([^>\s]+)>\n?(.*?)\n?</parameter>", re.S)
+END_TOKENS = ("<|im_end|>", "<|endoftext|>")
 
 # --------------------------------------------------------------------------------------------------------------------
-# Policy: Video-Coder-9B (Qwen3.5-9B, SFT + agentic RL)
+# Model: Video-Coder-9B (Qwen3.5-9B, vision-language) in bf16, fully on the GPU.
 # --------------------------------------------------------------------------------------------------------------------
 processor = AutoProcessor.from_pretrained(MODEL_ID)
+tokenizer = processor.tokenizer
 model = AutoModelForImageTextToText.from_pretrained(MODEL_ID, dtype=torch.bfloat16).to("cuda").eval()
-TOKENS_PER_SECOND = 22.0  # measured decode speed on ZeroGPU (large), used to size each turn's GPU reservation
-
 
-def _turn_duration(messages, max_new_tokens=6144, *args, **kwargs):
-    return int(min(600, 25 + int(max_new_tokens) / TOKENS_PER_SECOND))
+GPU_CHUNK_SECONDS = 90  # one GPU call generates for at most this long; long turns continue in the next call
 
 
-@spaces.GPU(duration=_turn_duration)
-def llm_turn(messages: list, max_new_tokens: int = 6144):
-    """One agent turn: stream the policy's reply. Yields (text_so_far, done, finish_reason)."""
-    inputs = processor.apply_chat_template(
-        messages, tools=[BASH_TOOL], add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt"
-    ).to("cuda")
-    streamer = TextIteratorStreamer(processor.tokenizer, skip_prompt=True, skip_special_tokens=False)
+@spaces.GPU(duration=120)
+def llm_chunk(messages: list, images: list, prefix: str = "", max_new_tokens: int = 16384,
+              temperature: float = 1.0, top_p: float = 0.95):
+    """Continue the agent's current turn for up to GPU_CHUNK_SECONDS; yields (text so far, finished, n_tokens)."""
+    prompt = tokenizer.apply_chat_template(messages, tools=TOOLS, add_generation_prompt=True, tokenize=False)
+    prompt += prefix
+    inputs = processor(text=[prompt], images=images or None, return_tensors="pt").to("cuda")
+    n_in = inputs["input_ids"].shape[1]
+    streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=False)
     result = {}
 
-    def run():
+    def _run():
         try:
-            out = model.generate(
-                **inputs, streamer=streamer, max_new_tokens=int(max_new_tokens), do_sample=True,
-                temperature=1.0, top_p=0.95, top_k=0,
-            )
-            result["n"] = out.shape[1] - inputs["input_ids"].shape[1]
-        except Exception as e:  # surfaced after the stream ends
+            out = model.generate(**inputs, streamer=streamer, max_new_tokens=int(max_new_tokens), do_sample=True,
+                                 temperature=float(temperature), top_p=float(top_p), top_k=0, use_cache=True,
+                                 max_time=GPU_CHUNK_SECONDS)
+            result["n"] = int(out.shape[1] - n_in)
+        except Exception as e:  # surfaced below
             result["error"] = f"{type(e).__name__}: {e}"
             streamer.end()
 
-    thread = threading.Thread(target=run, daemon=True)
-    thread.start()
+    th = threading.Thread(target=_run, daemon=True)
+    th.start()
     text = ""
-    for chunk in streamer:
-        text += chunk
-        yield text, False, None
-    thread.join()
+    last = 0.0
+    for piece in streamer:
+        text += piece
+        if time.time() - last > 0.4:
+            last = time.time()
+            yield text, False, None
+    th.join()
     if "error" in result:
-        raise gr.Error(f"Generation failed: {result['error']}")
-    finish = "stop" if ("<|im_end|>" in text or "<|endoftext|>" in text) else "length"
-    if finish == "length" and result.get("n", 0) < int(max_new_tokens):
-        finish = "stop"
-    text = text.replace("<|im_end|>", "").replace("<|endoftext|>", "")
-    yield text, True, finish
+        raise gr.Error(result["error"])
+    finished = any(t in text for t in END_TOKENS)
+    yield text, finished, result.get("n", 0)
 
 
 # --------------------------------------------------------------------------------------------------------------------
-# Harness glue (mini-swe-agent DefaultAgent + GuardedAgent semantics)
+# Agent loop: mini-swe-agent DefaultAgent + video_coder_harness GuardedAgent semantics, re-implemented without the
+# litellm/vLLM gateway (the model is called in-process).
 # --------------------------------------------------------------------------------------------------------------------
-_FUNC = re.compile(r"<function=([^>\n]+)>(.*?)</function>", re.S)
-_PARAM = re.compile(r"<parameter=([^>\n]+)>(.*?)</parameter>", re.S)
-
-
-def parse_reply(text: str):
-    """Qwen3-coder tool-call format -> (content before the first call, [(name, args)])."""
-    idx = text.find("<tool_call>")
-    content = text if idx < 0 else text[:idx]
-    calls = []
-    if idx >= 0:
-        for m in _FUNC.finditer(text[idx:]):
-            args = {}
-            for p in _PARAM.finditer(m.group(2)):
-                v = p.group(2)
-                v = v[1:] if v.startswith("\n") else v
-                v = v[:-1] if v.endswith("\n") else v
-                args[p.group(1).strip()] = v
-            calls.append((m.group(1).strip(), args))
-    return content.rstrip(), calls
-
-
-def split_reasoning(content: str):
-    if "</think>" in content:
-        r, c = content.split("</think>", 1)
-        return r.replace("<think>", "").strip(), c.strip()
-    return "", content.strip()
-
-
 def agent_env() -> dict:
-    env = {k: v for k, v in os.environ.items() if not _SECRET_ENV.search(k)}
-    env |= {k: str(v) for k, v in (ENV_CFG.get("env") or {}).items()}
+    env = dict(os.environ)
+    env.update({k: "" for k in os.environ if _SECRET_ENV.search(k)})
+    env.update({"PAGER": "cat", "MANPAGER": "cat", "PIP_PROGRESS_BAR": "off", "TQDM_DISABLE": "1"})
     env["PATH"] = f"{HARNESS_ROOT / 'bin'}:{os.environ.get('PATH', '')}"
     env["VCSFT_PYTHON"] = sys.executable
     env["VCSFT_HARNESS"] = json.dumps(HARNESS)
     return env
 
 
-def run_command(command: str, cwd: Path) -> dict:
-    reason = harness_violation(command, GUARD_MARKERS, str(cwd.resolve()))
-    if reason:
-        msg = ("BLOCKED: this command was not executed because {reason}. Work only in the current directory and use "
-               "only check_script and run_blender; do not inspect or modify the harness or run Blender any other way. "
-               "For a quick experiment, write a small script in the current directory and run `run_blender "
-               "experiment.py`; its print() output appears in the blender log.").format(reason=reason)
-        return {"output": msg, "returncode": 1, "exception_info": ""}
+def run_command(command: str, cwd: str) -> dict:
+    """mini-swe-agent LocalEnvironment.execute."""
+    proc = subprocess.Popen(command, shell=True, text=True, cwd=cwd, env=agent_env(), encoding="utf-8",
+                            errors="replace", stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+                            start_new_session=True)
     try:
-        r = subprocess.run(command, shell=True, cwd=cwd, env=agent_env(), text=True, encoding="utf-8",
-                           errors="replace", stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
-                           timeout=ENV_CFG.get("timeout", 900))
-        return {"output": r.stdout, "returncode": r.returncode, "exception_info": ""}
-    except Exception as e:
-        raw = getattr(e, "output", None)
-        raw = raw.decode("utf-8", errors="replace") if isinstance(raw, bytes) else (raw or "")
-        return {"output": raw, "returncode": -1, "exception_info": f"An error occurred while executing the command: {e}"}
-
-
-def observation_content(output: dict):
-    """video_coder_harness.models.VisualChatModel: cut image tags out, template the text, attach the images."""
-    text = output.get("output") or ""
+        stdout, _ = proc.communicate(timeout=CMD_TIMEOUT)
+        return {"output": stdout, "returncode": proc.returncode, "exception_info": ""}
+    except subprocess.TimeoutExpired as e:
+        os.killpg(proc.pid, signal.SIGKILL)
+        stdout, _ = proc.communicate()
+        return {"output": stdout or "", "returncode": -1,
+                "exception_info": f"An error occurred while executing the command: {e}"}
+
+
+def is_submit(output: dict) -> bool:
+    lines = output.get("output", "").lstrip().splitlines()
+    return bool(lines) and lines[0].strip() == "COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT" and output["returncode"] == 0
+
+
+def split_images(text: str):
+    """video_coder_harness.models.split_images: cut frame images out of the tool output."""
     images = []
 
     def repl(m):
         if m.group(1).strip() != "image_url":
             return m.group(0)
         before = text[: m.start()].rstrip().splitlines()
-        images.append((before[-1].strip() if before else "", m.group(2).strip()))
+        caption = before[-1].strip() if before else ""
+        images.append((caption, m.group(2).strip()))
         return f"[image {len(images)} attached below]"
 
-    stripped = _TAG.sub(repl, text)
-    body = render_template(MODEL_CFG["observation_template"], output={**output, "output": stripped})
-    if not images:
-        return body, body, []
-    content = [{"type": "text", "text": body}]
-    for k, (caption, url) in enumerate(images, 1):
-        content += [{"type": "text", "text": f"image {k}: {caption}" if caption else f"image {k}:"},
-                    {"type": "image", "image": url}]
-    return content, body, images
+    return MM_TAG.sub(repl, text), images
 
 
-def truncate(s: str, n: int = 2500) -> str:
-    return s if len(s) <= n else s[: n // 2] + f"\n… [{len(s) - n} chars elided] …\n" + s[-n // 2:]
+def data_url_to_pil(url: str) -> Image.Image:
+    return Image.open(io.BytesIO(base64.b64decode(url.split(",", 1)[1]))).convert("RGB")
 
 
-def show_command(cmd: str) -> str:
-    lines = cmd.splitlines()
-    if len(lines) > 30:
-        cmd = "\n".join(lines[:30]) + f"\n# … {len(lines) - 30} more lines (full script in the Blender script panel)"
-    return f"```bash\n{cmd}\n```"
+def parse_response(raw: str):
+    """Split a Qwen3.5 response into (reasoning, content, tool calls) like vLLM's qwen3 reasoning + qwen3_coder parsers."""
+    text = raw
+    for t in END_TOKENS:
+        text = text.split(t)[0]
+    reasoning = ""
+    if "</think>" in text:
+        reasoning, text = text.split("</think>", 1)
+        reasoning = reasoning.replace("<think>", "").strip()
+    calls = []
+    for m in TOOL_CALL_RE.finditer(text):
+        args = {k: v for k, v in PARAM_RE.findall(m.group(2))}
+        calls.append({"name": m.group(1).strip(), "arguments": args})
+    content = TOOL_CALL_RE.sub("", text)
+    content = content.split("<tool_call>")[0].strip()
+    return reasoning, content, calls
+
+
+def sha(path: Path) -> str | None:
+    return hashlib.sha256(path.read_bytes()).hexdigest() if path.is_file() else None
+
 
+def short(text: str, n: int = 60) -> str:
+    lines = text.splitlines()
+    return text if len(lines) <= n else "\n".join(lines[:n]) + f"\n... ({len(lines) - n} more lines)"
 
-def read_script(ws: Path) -> str:
-    p = ws / HARNESS["script_name"]
+
+def read_script(workdir: Path) -> str:
+    p = workdir / SCRIPT
     return p.read_text(errors="replace") if p.is_file() else ""
 
 
-def generate(prompt: str, max_steps: int = 20, max_new_tokens: int = 6144):
-    """Run the Video-Coder agent on a scene description and return its Blender-rendered draft video.
+def new_state(prompt: str, max_steps: int, temperature: float, top_p: float, max_new_tokens: int) -> dict:
+    workdir = (RUNS_DIR / uuid.uuid4().hex).resolve()
+    workdir.mkdir(parents=True)
+    return {
+        "workdir": str(workdir),
+        "messages": [
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": INSTANCE_TEMPLATE.replace("__TASK__", prompt.strip())},
+        ],
+        "image_urls": [],  # frames shown to the model, in order (JPEG data URLs)
+        "chat": [],
+        "video": None,
+        "preview": None,
+        "last_ok": None,  # (script hash, video) of the last run_blender that reported RUN OK
+        "last_key": None,
+        "repeats": 0,
+        "n_format_errors": 0,
+        "step": 1,
+        "raw": "",  # current (possibly unfinished) model turn
+        "used": 0,
+        "max_steps": int(max_steps),
+        "temperature": float(temperature),
+        "top_p": float(top_p),
+        "max_new_tokens": int(max_new_tokens),
+        "done": False,
+        "status": "Starting…",
+        "t_start": time.time(),
+    }
+
+
+def ui(state: dict, tick=None):
+    workdir = Path(state["workdir"])
+    msg = f"**{state['status']}** · {time.time() - state['t_start']:.0f}s elapsed"
+    return (state, state["chat"], state["video"], read_script(workdir), state["preview"], msg,
+            gr.update() if tick is None else tick)
+
+
+def start(prompt: str, max_steps: int = 16, temperature: float = 1.0, top_p: float = 0.95,
+          max_new_tokens: int = 16384):
+    """Start a Video-Coder agent run for a scene description. The run then proceeds turn by turn: call `advance`
+    with the returned state (same session) until its status says it finished.
 
     Args:
-        prompt: scene description (objects, layout, motion, camera).
-        max_steps: maximum number of agent turns (model calls).
-        max_new_tokens: maximum tokens the model may generate per turn.
-
-    Returns:
-        (agent trace, Blender script, draft video path, status)
+        prompt: description of the scene / video to build.
+        max_steps: maximum number of agent turns (one bash command each).
+        temperature: sampling temperature (the authors sample with 1.0).
+        top_p: nucleus sampling (the authors use 0.95).
+        max_new_tokens: token budget of a single agent turn.
     """
     if not prompt or not prompt.strip():
-        raise gr.Error("Describe a scene first.")
-    task = prompt.strip()
-    run_id = uuid.uuid4().hex[:10]
-    root = RUNS_DIR / run_id
-    ws = root / "workspace"
-    ws.mkdir(parents=True)
-    tv = {**TEMPLATE_VARS, "task": task}
-    messages = [
-        {"role": "system", "content": render_template(AGENT_CFG["system_template"], **tv)},
-        {"role": "user", "content": render_template(AGENT_CFG["instance_template"], **tv)},
-    ]
-    chat = [{"role": "user", "content": task}]
-    script, draft, status = "", None, "Starting the agent…"
-    yield chat, script, draft, status
-
-    last, repeats, format_errors, submitted, n_calls = None, 0, 0, False, 0
-    exit_status = "StepLimit"
-    t_start = time.time()
-    while n_calls < int(max_steps):
-        n_calls += 1
-        chat.append({"role": "assistant", "content": "", "metadata": {"title": f"💭 Step {n_calls}: thinking…"}})
-        text, finish = "", None
-        for text, done, finish in llm_turn(messages, int(max_new_tokens)):
-            reasoning, visible = split_reasoning(text.split("<tool_call>")[0])
-            chat[-1]["content"] = truncate((reasoning or visible), 6000)
-            yield chat, script, draft, f"Step {n_calls}: the model is writing…"
-        content, calls = parse_reply(text)
-        reasoning, visible = split_reasoning(content)
-        chat[-1]["content"] = truncate(reasoning, 6000) or "(no reasoning)"
-        chat[-1]["metadata"] = {"title": f"💭 Step {n_calls}: reasoning"}
-        if visible:
-            chat.append({"role": "assistant", "content": visible})
-
-        actions = [a.get("command") for name, a in calls if name == "bash" and "command" in a]
-        if not calls or len(actions) != len(calls):
-            format_errors += 1
-            err = ("No tool calls found in the response. Every response MUST include at least one tool call."
-                   if not calls else "Missing 'command' argument in bash tool call.")
-            messages.append({"role": "user", "content": render_template(
-                MODEL_CFG["format_error_template"], error=err, actions=[], has_tool_calls=bool(calls),
-                finish_reason=finish or "stop")})
-            chat.append({"role": "assistant", "content": f"⚠️ Format error ({'output limit reached' if finish == 'length' else err}); asking the model to retry."})
-            yield chat, script, draft, status
-            if format_errors >= AGENT_CFG.get("max_consecutive_format_errors", 3):
-                exit_status = "FormatError"
-                break
-            continue
-        format_errors = 0
-        messages.append({
-            "role": "assistant", "content": content,
-            "tool_calls": [{"type": "function", "function": {"name": "bash", "arguments": {"command": c}}} for c in actions],
-        })
-
-        stop = False
-        for cmd in actions:
-            chat.append({"role": "assistant", "content": show_command(cmd)})
-            yield chat, read_script(ws) or script, draft, f"Step {n_calls}: running the command…"
-            out = run_command(cmd, ws)
-            lines = (out.get("output") or "").lstrip().splitlines()
-            if lines and lines[0].strip() == SUBMIT and out["returncode"] == 0:
-                submitted, stop, exit_status = True, True, "Submitted"
-                chat.append({"role": "assistant", "content": "✅ The agent submitted its script."})
-                break
-            key = (cmd, _normalize_output(out.get("output", "")))
-            same = (last is not None and key[1] == last[1]
-                    and difflib.SequenceMatcher(None, key[0], last[0]).ratio() >= 0.9)
-            repeats = repeats + 1 if same else 1
-            last = key
-            if repeats >= AGENT_CFG.get("repeat_warn", 3):
-                out["output"] = (out.get("output") or "") + (
-                    f"\n\nWARNING: this is the {repeats}th consecutive near-identical command with the same result. "
-                    "Repeating it will not help: read the output, then change the script or your approach. The task "
-                    f"ends after {AGENT_CFG.get('repeat_stop', 6)} repetitions.")
-            if repeats >= AGENT_CFG.get("repeat_stop", 6):
-                stop, exit_status = True, "RepeatedActions"
-            obs, obs_text, images = observation_content(out)
+        raise gr.Error("Please enter a scene description.")
+    state = new_state(prompt, max_steps, temperature, top_p, max_new_tokens)
+    return ui(state, tick=time.time())
+
+
+def _finish_turn(state: dict):
+    """Parse the finished model turn, run its command(s) in the harness; a generator of UI updates."""
+    workdir = Path(state["workdir"])
+    step, raw = state["step"], state["raw"]
+    chat, messages = state["chat"], state["messages"]
+    if chat and chat[-1].get("metadata", {}).get("status") == "pending":
+        chat.pop()
+    reasoning, content, calls = parse_response(raw)
+    state["raw"], state["used"] = "", 0
+    if reasoning:
+        chat.append({"role": "assistant", "content": reasoning,
+                     "metadata": {"title": f"💭 Step {step}: reasoning", "status": "done"}})
+    msg = {"role": "assistant", "content": content}
+    if reasoning:
+        msg["reasoning_content"] = reasoning
+    if calls:
+        msg["tool_calls"] = [{"type": "function", "function": {"name": c["name"], "arguments": c["arguments"]}}
+                             for c in calls]
+    messages.append(msg)
+
+    error = None
+    if not calls:
+        error = "No tool calls found in the response. Every response MUST include at least one tool call."
+    elif any(c["name"] != "bash" or "command" not in c["arguments"] for c in calls):
+        error = "Unknown tool or missing 'command' argument."
+    if error:
+        state["n_format_errors"] += 1
+        finish_reason = "length" if not any(t in raw for t in END_TOKENS) else "stop"
+        err = FORMAT_ERROR_TEMPLATE.render(error=error, finish_reason=finish_reason, has_tool_calls=bool(calls))
+        if content:
+            chat.append({"role": "assistant", "content": content})
+        chat.append({"role": "user", "content": f"⚠️ {err}"})
+        messages.append({"role": "user", "content": err})
+        if state["n_format_errors"] >= MAX_FORMAT_ERRORS:
+            return "FormatError"
+        return None
+    state["n_format_errors"] = 0
+
+    for call in calls:
+        command = call["arguments"]["command"]
+        shown = f"{content}\n\n" if content else ""
+        chat.append({"role": "assistant", "content": f"{shown}```bash\n{short(command)}\n```"})
+        first = command.strip().splitlines()[0][:60] if command.strip() else ""
+        state["status"] = f"Step {step}: running `{first}`"
+        yield
+        reason = harness_violation(command, HARNESS_MARKERS, str(workdir))
+        if reason:
+            out = {"output": BLOCKED.format(reason=reason), "returncode": 1, "exception_info": ""}
+        else:
+            out = run_command(command, str(workdir))
+            if is_submit(out):
+                return "Submitted"
+        key = (command, _normalize_output(out.get("output", "")))
+        last = state["last_key"]
+        same = (last is not None and key[1] == last[1]
+                and difflib.SequenceMatcher(None, key[0], last[0]).ratio() >= REPEAT_SIM)
+        state["repeats"] = state["repeats"] + 1 if same else 1
+        state["last_key"] = key
+        if state["repeats"] >= REPEAT_WARN:
+            out["output"] = (out.get("output") or "") + REPEAT_WARNING.format(n=state["repeats"], stop=REPEAT_STOP)
+
+        text, imgs = split_images(out.get("output") or "")
+        obs = OBSERVATION_TEMPLATE.render(output={**out, "output": text})
+        if imgs:
+            parts = [{"type": "text", "text": obs}]
+            for k, (caption, url) in enumerate(imgs, 1):
+                parts += [{"type": "text", "text": f"image {k}: {caption}" if caption else f"image {k}:"},
+                          {"type": "image"}]
+                state["image_urls"].append(url)
+            messages.append({"role": "tool", "content": parts})
+        else:
             messages.append({"role": "tool", "content": obs})
-            chat.append({"role": "assistant", "content": f"```\n{truncate(obs_text)}\n```",
-                         "metadata": {"title": f"🛠️ Output (exit {out['returncode']})"}})
-            script = read_script(ws) or script
-            preview = ws / "preview.png"
-            if images and preview.is_file():
-                keep = root / f"preview_{n_calls}.png"
-                shutil.copy(preview, keep)
-                chat.append({"role": "assistant", "content": gr.Image(str(keep), label=f"Render after step {n_calls}")})
-            if (ws / HARNESS["output_video"]).is_file() and "RUN OK" in (out.get("output") or ""):
-                keep = root / f"render_{n_calls}.mp4"
-                shutil.copy(ws / HARNESS["output_video"], keep)
-                draft = str(keep)
-            yield chat, script, draft, f"Step {n_calls} done ({time.time() - t_start:.0f}s)"
-        if stop:
-            break
 
-    script = read_script(ws) or script
-    if submitted:
-        yield chat, script, draft, "Submitted: re-rendering the final script from scratch (harness acceptance)…"
-        check = check_file(ws / HARNESS["script_name"])
-        accepted = False
-        if check["ok"]:
-            final_dir = root / "final_run"
-            final_dir.mkdir()
-            shutil.copy(ws / HARNESS["script_name"], final_dir / HARNESS["script_name"])
-            rep = execute(final_dir / HARNESS["script_name"], final_dir, HARNESS)
-            accepted = bool(rep["ok"])
-            if accepted:
-                draft = str(final_dir / HARNESS["output_video"])
-        if accepted:
-            status = f"✅ Accepted: the final script renders a valid draft video ({n_calls} steps, {time.time() - t_start:.0f}s)."
-        else:
-            status = "⚠️ Submitted, but the final re-render did not pass the harness checks" + (
-                " (showing the last successful render)." if draft else ".")
+        if command.strip().startswith("run_blender"):
+            vid = workdir / HARNESS["output_video"]
+            if vid.is_file():
+                keep = workdir / f"render_step{step}.mp4"
+                shutil.copy(vid, keep)
+                state["video"] = str(keep)
+                if text.startswith("RUN OK"):
+                    state["last_ok"] = (sha(workdir / SCRIPT), str(keep))
+            if (workdir / "preview.png").is_file():
+                keep_png = workdir / f"preview_step{step}.png"
+                shutil.copy(workdir / "preview.png", keep_png)
+                state["preview"] = str(keep_png)
+        chat.append({"role": "assistant", "content": f"```\n{short(text.strip(), 40)}\n```",
+                     "metadata": {"title": f"🛠️ Output (exit code {out['returncode']})", "status": "done"}})
+        if state["repeats"] >= REPEAT_STOP:
+            return "RepeatedActions"
+    return None
+
+
+def _accept(state: dict):
+    """Harness acceptance: static check + the submitted script re-rendered from scratch (final_execution)."""
+    workdir = Path(state["workdir"])
+    script = workdir / SCRIPT
+    state["chat"].append({"role": "assistant", "content": "✅ Submitted. Validating the final script…"})
+    if not script.is_file():
+        state["status"] = f"Submitted, but no {SCRIPT} was written"
+        return
+    check = check_file(script)
+    if not check["ok"]:
+        state["status"] = f"Submitted, but the static check failed: {check['errors']}"
+        return
+    last_ok = state["last_ok"]
+    if last_ok and last_ok[0] == sha(script):  # Workbench rendering is deterministic: reuse the identical render
+        state["video"] = last_ok[1]
     else:
-        status = f"⚠️ Stopped ({exit_status}) after {n_calls} steps without a submission" + (
-            "; showing the last successful render." if draft else ".")
-    yield chat, script, draft, status
-
-
-# --------------------------------------------------------------------------------------------------------------------
-# Stage 2: draft -> final video with MiniMax-H3 Ref2VA (Minimax-H3-server/batch_generate.py's prompt template)
-# --------------------------------------------------------------------------------------------------------------------
-H3_TEMPLATE = """Generate a high-quality, photorealistic video based on the following scene description and white-model reference video.
-
-Use the scene description to determine the objects, colors, materials, and visual appearance. Follow the white-model video to preserve the scene layout, object movements, camera motion, and timing.
-
-Maintain visual realism and temporal consistency.
-
-Scene Description:
-{scene}
-
-Reference Video:
-<Video 1>"""
+        state["status"] = "Re-rendering the submitted script"
+        yield
+        final_dir = workdir / "final_run"
+        final_dir.mkdir(exist_ok=True)
+        shutil.copy(script, final_dir / SCRIPT)
+        report = blender_execute(final_dir / SCRIPT, final_dir, HARNESS)
+        if (final_dir / HARNESS["output_video"]).is_file():
+            state["video"] = str(final_dir / HARNESS["output_video"])
+        if (final_dir / "preview.png").is_file():
+            state["preview"] = str(final_dir / "preview.png")
+        if not report["ok"]:
+            state["status"] = f"Submitted, but the final render has problems: {report['problems']}"
+            return
+    state["status"] = "Accepted ✅ — draft video rendered from the agent's Blender script"
+
+
+def advance(state: dict):
+    """Run the next piece of the agent: one GPU generation chunk of the current turn and, once the turn is complete,
+    its bash command in the Video-Coder harness. Returns a new tick while the run is still going.
 
+    Args:
+        state: the run state returned by `start` / the previous `advance`.
+    """
+    if not state or state.get("done"):
+        yield ui(state) if state else (state, gr.update(), gr.update(), gr.update(), gr.update(), gr.update(),
+                                       gr.update())
+        return
+    step = state["step"]
+    chat = state["chat"]
+    if not (chat and chat[-1].get("metadata", {}).get("status") == "pending"):
+        chat.append({"role": "assistant", "content": "",
+                     "metadata": {"title": f"💭 Step {step}: thinking…", "status": "pending"}})
+    live = chat[-1]
+    state["status"] = f"Step {step}/{state['max_steps']}: Video-Coder is thinking"
+    yield ui(state)
+
+    # ---- one GPU call (the ZeroGPU token of a request is short-lived, so each request makes exactly one) ----
+    images = [data_url_to_pil(u) for u in state["image_urls"]]
+    base = state["raw"]
+    finished, n = False, None
+    t0 = time.time()
+    for text, finished, n in llm_chunk(state["messages"], images, base, state["max_new_tokens"] - state["used"],
+                                       state["temperature"], state["top_p"]):
+        state["raw"] = base + text
+        live["content"] = state["raw"][-3000:].replace("<think>", "")
+        state["status"] = f"Step {step}/{state['max_steps']}: Video-Coder is writing ({len(state['raw'])} chars)"
+        yield ui(state)
+    state["used"] += n or 0
+    print(f"step {step}: chunk {time.time() - t0:.1f}s, {n} tokens, finished={finished}")
+    if not finished and state["used"] < state["max_new_tokens"]:
+        yield ui(state, tick=time.time())  # continue this turn in the next request
+        return
 
-def render_final(prompt: str, draft_video: str, request: gr.Request = None):
-    """Turn the white-model draft into a photorealistic video with MiniMax-H3 (Ref2VA), via a public H3 Space."""
-    if not draft_video:
-        raise gr.Error("Generate a draft video first.")
-    from gradio_client import Client, handle_file
+    # ---- the turn is complete: execute it ----
+    exit_status = None
+    gen = _finish_turn(state)
+    while True:
+        try:
+            next(gen)
+            yield ui(state)
+        except StopIteration as stop:
+            exit_status = stop.value
+            break
+    state["step"] += 1
+    if exit_status is None and state["step"] > state["max_steps"]:
+        exit_status = "StepLimit"
+    if exit_status is None:
+        state["status"] = f"Step {step}/{state['max_steps']} done"
+        yield ui(state, tick=time.time())
+        return
+    state["done"] = True
+    if exit_status == "Submitted":
+        for _ in _accept(state):
+            yield ui(state)
+    else:
+        state["status"] = {
+            "StepLimit": "Step limit reached before the agent submitted (showing the latest render)",
+            "RepeatedActions": "Stopped: the agent repeated the same command",
+            "FormatError": "Stopped after repeated format errors",
+        }[exit_status]
+    yield ui(state)
 
-    from video_coder_harness.video import probe
 
-    info = probe(draft_video)
-    seconds = (info.get("n_frames") or 120) / (info.get("fps") or 24)
-    headers = {}
-    if request is not None and request.headers.get("x-ip-token"):
-        headers["x-ip-token"] = request.headers["x-ip-token"]
-    try:
-        client = Client(H3_SPACE, headers=headers or None)
-        video, _ = client.predict(
-            prompt=H3_TEMPLATE.format(scene=(prompt or "").strip()),
-            video_path={"video": handle_file(draft_video)},
-            canvas="960x544 · 16:9 fast", match=False, duration=int(max(2, min(14, round(seconds)))),
-            steps=28, seed=42, upsample=False, api_name="/generate",
-        )
-    except Exception as e:
-        raise gr.Error(f"MiniMax-H3 ({H3_SPACE}) failed: {type(e).__name__}: {e}")
-    return video["video"] if isinstance(video, dict) else video
+def stop_run(state: dict):
+    """Stop the current run."""
+    if state:
+        state["done"] = True
+        state["status"] = "Stopped"
+        return ui(state)
+    return (state, gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update())
 
 
 # --------------------------------------------------------------------------------------------------------------------
 # UI
 # --------------------------------------------------------------------------------------------------------------------
-EXAMPLES = [  # the authors' qualitative examples (project page) and their H3 demo scene
-    "The video captures a small bird perched on a tree branch. The bird, with its brown and white feathers, yellow beak, and black and white head, is the main focus of the video. The bird is seen in three different positions on the branch, each time facing a different direction. The background of the video is filled with green foliage, providing a natural and serene setting for the bird. The style of the video is a close-up shot, allowing the viewer to appreciate the details of the bird and its surroundings. The video does not contain any text or additional objects. The bird's movements and the changing angles of the shot create a sense of dynamism and life in the video.",
-    "The video shows a sequence of three identical white cars driving on a road. The first car is in the foreground, the second car is slightly behind and to the right, and the third car is in the background. The cars are moving from left to right across the frame. The road appears to be a city street with a dark grey surface. The background features a city skyline with buildings of various heights, and the sky is a gradient of orange and yellow, suggesting either sunrise or sunset. The style of the video is realistic with a focus on the cars and their movement.",
-    "A single polished walnut-wood chess pawn stands on a small square pedestal of white Carrara marble. No other objects are in the scene. Dark charcoal studio backdrop, soft key light from the upper left with a gentle rim light, subtle reflections on the marble. The camera makes one complete 360-degree orbit around the pawn while slowly rising.",
-    "The video captures a lively scene on the ocean, with three boats in motion. The first boat, a large white yacht, is seen in the distance, sailing towards the horizon. The second and third boats are closer to the viewer, both moving at high speeds, leaving trails of white water behind them. The ocean is a deep blue, and the sky above is clear, suggesting a sunny day. The boats are the main focus of the video, with their movement and the water's reaction to their speed creating a dynamic and exciting scene. The overall style of the video is a dynamic aerial shot, capturing the movement and beauty of the ocean and the boats.",
-    "In the video, a woman with long dark hair and glasses is seen enjoying a meal. She is wearing a black jacket and is seated in a room with a white wall. In the first frame, she is holding a bowl of food and appears to be in the process of eating. In the second frame, she is seen taking a bite of her food. In the third frame, she is seen holding a spoon and appears to be in the process of eating again. The video captures the woman's enjoyment of her meal and the casual atmosphere of the setting.",
-]
-
-INTRO = """# 🎬 Video-Coder
-**Video-Coder-9B** is a coding agent: given a scene description it writes a Blender Python program, runs it, looks at the
-rendered frames, fixes what is wrong, and submits a **draft video**, an untextured 3D render whose layout, motion and
-camera then guide a video generator ([MiniMax-H3](https://huggingface.co/MiniMaxAI/MiniMax-H3)).
-
-[📄 Paper](https://huggingface.co/papers/2611.09894) · [💻 Code](https://github.com/CYWang735/Video-Coder) ·
-[🤗 Model](https://huggingface.co/Video-Coder/Video-Coder-9B) · [🌐 Project page](https://cywang735.github.io/Video-Coder/)
-
-A run takes several minutes: each agent turn is a GPU call and every `run_blender` renders 5–10 s of 720p video on CPU.
-"""
-
 CSS = """
-#col-container { max-width: 1300px; margin: 0 auto; }
+#col-container { max-width: 1280px; margin: 0 auto; }
 .dark .gradio-container { color: var(--body-text-color); }
 """
 
+EXAMPLES = [
+    "The video captures a small bird perched on a tree branch. The bird, with its brown and white feathers, yellow "
+    "beak, and black and white head, is the main focus of the video. The bird is seen in three different positions on "
+    "the branch, each time facing a different direction. The background of the video is filled with green foliage, "
+    "providing a natural and serene setting for the bird. The style of the video is a close-up shot.",
+    "A single polished walnut-wood chess pawn stands on a small square pedestal of white Carrara marble. No other "
+    "objects are in the scene. The camera makes one complete 360-degree orbit around the pawn while slowly rising.",
+    "The video shows a sequence of three identical white cars driving on a road. The first car is in the foreground, "
+    "the second car is slightly behind and to the right, and the third car is in the background. The cars are moving "
+    "from left to right across the frame. The road appears to be a city street with a dark grey surface. The "
+    "background features a city skyline with buildings of various heights, and the sky is a gradient of orange and "
+    "yellow, suggesting either sunrise or sunset. The style of the video is realistic with a focus on the cars and "
+    "their movement.",
+    "a man standing in front of a machine.",
+    "The video captures a lively scene on the ocean, with three boats in motion. The first boat, a large white yacht, "
+    "is seen in the distance, sailing towards the horizon. The second and third boats are closer to the viewer, both "
+    "moving at high speeds, leaving trails of white water behind them. The ocean is a deep blue, and the sky above is "
+    "clear, suggesting a sunny day. The boats are the main focus of the video, with their movement and the water's "
+    "reaction to their speed creating a dynamic and exciting scene. The overall style of the video is a dynamic "
+    "aerial shot, capturing the movement and beauty of the ocean and the boats.",
+]
+
 with gr.Blocks(title="Video-Coder") as demo:
     with gr.Column(elem_id="col-container"):
-        gr.Markdown(INTRO)
+        gr.Markdown(
+            "# 🎬 Video-Coder: agentic coding for video generation\n"
+            "**Video-Coder-9B** writes and runs a Blender Python program for your scene description, inspects the "
+            "rendered frames, fixes what is wrong and submits a **draft video** (white-model 3D render with the "
+            "layout, motion and camera of the scene) — the structure/motion signal the paper feeds to a downstream "
+            "video generator.\n\n"
+            "[📖 Paper](https://huggingface.co/papers/2611.09894) · [🌐 Project page](https://cywang735.github.io/"
+            "Video-Coder/) · [💻 Code](https://github.com/CYWang735/Video-Coder) · [🤗 Model](https://huggingface.co/"
+            "Video-Coder/Video-Coder-9B)\n\n"
+            "⏳ A full agent run takes several minutes: the first turn writes a long script, and every `run_blender` "
+            "renders the animation with Blender on CPU. The trajectory streams live; keep this tab open."
+        )
+        with gr.Row():
+            prompt = gr.Textbox(label="Scene description", lines=3, scale=4,
+                                placeholder="Describe the scene and its motion, e.g. 'a red ball rolls down a ramp "
+                                            "and knocks over three dominoes'")
+            with gr.Column(scale=1, min_width=180):
+                run_btn = gr.Button("Generate draft video", variant="primary")
+                stop_btn = gr.Button("Stop", variant="stop")
+        status = gr.Markdown()
         with gr.Row():
-            with gr.Column(scale=5):
-                prompt = gr.Textbox(label="Scene description", lines=4,
-                                    placeholder="Describe the objects, how they move and what the camera does…")
-                run = gr.Button("Write & render draft video", variant="primary")
-                status = gr.Markdown("")
-                draft = gr.Video(label="Draft video (Blender, white model)", autoplay=True)
-                with gr.Accordion("Agent settings", open=False):
-                    max_steps = gr.Slider(4, 40, value=20, step=1, label="Max agent steps (model calls)")
-                    max_new_tokens = gr.Slider(1024, 12288, value=6144, step=256, label="Max new tokens per step")
-                with gr.Accordion("Stage 2: final video with MiniMax-H3 (optional)", open=False):
-                    gr.Markdown(f"Sends the draft and your description to MiniMax-H3 Ref2VA with the authors' white-model "
-                                f"prompt template, through the public [{H3_SPACE}](https://huggingface.co/spaces/{H3_SPACE}) "
-                                "Space (it uses your own ZeroGPU quota, takes a few minutes).")
-                    final_btn = gr.Button("Generate final video")
-                    final = gr.Video(label="Final video (MiniMax-H3)")
-            with gr.Column(scale=6):
-                chat = gr.Chatbot(label="Agent trace", height=640, layout="panel")
-                with gr.Accordion("Blender script (main.py)", open=True):
-                    code = gr.Code(language="python", label="main.py", interactive=False)
-
-        gr.Examples(examples=[[e] for e in EXAMPLES], inputs=[prompt], outputs=[chat, code, draft, status],
-                    fn=generate, cache_examples=False, run_on_click=True, examples_per_page=5)
-
-    run.click(generate, [prompt, max_steps, max_new_tokens], [chat, code, draft, status],
-              api_name="generate", concurrency_limit=2)
-    prompt.submit(generate, [prompt, max_steps, max_new_tokens], [chat, code, draft, status],
-                  api_name=False, concurrency_limit=2)
-    final_btn.click(render_final, [prompt, draft], [final], api_name="render_final")
+            with gr.Column(scale=1):
+                video_out = gr.Video(label="Draft video (Blender render)", autoplay=True)
+                preview_out = gr.Image(label="Latest render: frames 1, ⅓, ⅔, last", type="filepath")
+            with gr.Column(scale=1):
+                with gr.Tabs():
+                    with gr.Tab("Agent trajectory"):
+                        chat_out = gr.Chatbot(label="Video-Coder harness", height=640, show_label=False)
+                    with gr.Tab("main.py"):
+                        code_out = gr.Code(label="Blender script written by the agent", language="python",
+                                           lines=30)
+        with gr.Accordion("Advanced settings", open=False):
+            max_steps = gr.Slider(2, 40, value=16, step=1, label="Max agent steps (one bash command each)")
+            temperature = gr.Slider(0.1, 1.5, value=1.0, step=0.05, label="Temperature")
+            top_p = gr.Slider(0.5, 1.0, value=0.95, step=0.01, label="Top-p")
+            max_new_tokens = gr.Slider(2048, 32768, value=16384, step=1024, label="Max tokens per agent turn")
+
+        state = gr.State(None)
+        tick = gr.Number(value=0, visible=False)
+        outputs = [state, chat_out, video_out, code_out, preview_out, status, tick]
+        inputs = [prompt, max_steps, temperature, top_p, max_new_tokens]
+        run_btn.click(start, inputs=inputs, outputs=outputs, api_name="start")
+        prompt.submit(start, inputs=inputs, outputs=outputs, api_visibility="private")
+        # Each agent step is its own request (fresh ZeroGPU token); the tick change chains the next one.
+        adv = tick.change(advance, inputs=[state], outputs=outputs, api_name="advance", concurrency_limit=None)
+        stop_btn.click(stop_run, inputs=[state], outputs=outputs, cancels=[adv], api_name="stop")
+        gr.Examples(examples=[[e] for e in EXAMPLES], inputs=[prompt], outputs=outputs, fn=start,
+                    cache_examples=False, run_on_click=True)
 
 if __name__ == "__main__":
-    demo.queue(default_concurrency_limit=4).launch(theme=gr.themes.Citrus(), css=CSS, mcp_server=True, show_error=True)
+    demo.queue().launch(theme=gr.themes.Citrus(), css=CSS, mcp_server=True)

packages.txt

@@ -3,6 +3,7 @@ libxrender1
 libxxf86vm1
 libxfixes3
 libxi6
+libxext6
 libxkbcommon0
 libsm6
 libgl1

requirements.txt

@@ -1,9 +1,8 @@
 transformers>=5.17.0
-accelerate
 torchvision
+accelerate
 flash-linear-attention
-pillow
-pyyaml
-jinja2
 imageio-ffmpeg
 uv
+pillow
+pyyaml