Video-Coder agent demo

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 3D draft video
+short_description: Agent writes Blender code to build a 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
+# Video-Coder: Reinforcing Agentic Coding for Video Generation
 
-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)).
+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**.
 
-**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).
+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).
 
-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.
+`harness/` contains code copied from the Video-Coder repository (Apache-2.0). Example prompts are the authors' own
+qualitative examples from the project page.

app.py

@@ -1,19 +1,27 @@
+"""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  (must come before torch)
+import spaces  # noqa: E402  (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
@@ -22,90 +30,64 @@ 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
 
-ROOT = Path(__file__).resolve().parent
-HARNESS_ROOT = ROOT / "harness"
+APP_DIR = Path(__file__).resolve().parent
+HARNESS_ROOT = APP_DIR / "harness"
 sys.path.insert(0, str(HARNESS_ROOT))
-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 guard import _normalize_output, harness_violation  # noqa: E402
+from video_coder_harness.blender_exec import execute  # noqa: E402
 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 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.
+# 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).
 # --------------------------------------------------------------------------------------------------------------------
-BPY_ENV = Path(os.environ.get("BPY_ENV", str(Path.home() / "bpyenv")))
-BPY_PY = BPY_ENV / "bin" / "python"
+BPY_ENV = Path(os.environ.get("BPY_ENV", str(Path.home() / "bpy45")))
+BPY_PYTHON = BPY_ENV / "bin" / "python"
 
 
 def setup_bpy() -> None:
-    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
+    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")
     t0 = time.time()
-    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:])
+    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)
 
 
 setup_bpy()
 
-# 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,
+_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"],
     "visual_feedback": True,
-    "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",
+    "preview_frames": HARNESS.get("preview_frames", 8),
+    "judge_enabled": False,
 }
-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 = [{
+BASH_TOOL = {  # mini-swe-agent's tool definition (minisweagent.models.utils.actions_toolcall.BASH_TOOL)
     "type": "function",
     "function": {
         "name": "bash",
@@ -116,505 +98,422 @@ TOOLS = [{
             "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 %}
 }
-{%- 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|>")
+_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()
 
 # --------------------------------------------------------------------------------------------------------------------
-# Model: Video-Coder-9B (Qwen3.5-9B, vision-language) in bf16, fully on the GPU.
+# Policy: Video-Coder-9B (Qwen3.5-9B, SFT + agentic RL)
 # --------------------------------------------------------------------------------------------------------------------
 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
+
 
-GPU_CHUNK_SECONDS = 90  # one GPU call generates for at most this long; long turns continue in the next call
+def _turn_duration(messages, max_new_tokens=6144, *args, **kwargs):
+    return int(min(600, 25 + int(max_new_tokens) / TOKENS_PER_SECOND))
 
 
-@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)
+@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)
     result = {}
 
-    def _run():
+    def run():
         try:
-            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
+            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
             result["error"] = f"{type(e).__name__}: {e}"
             streamer.end()
 
-    th = threading.Thread(target=_run, daemon=True)
-    th.start()
+    thread = threading.Thread(target=run, daemon=True)
+    thread.start()
     text = ""
-    last = 0.0
-    for piece in streamer:
-        text += piece
-        if time.time() - last > 0.4:
-            last = time.time()
-            yield text, False, None
-    th.join()
+    for chunk in streamer:
+        text += chunk
+        yield text, False, None
+    thread.join()
     if "error" in result:
-        raise gr.Error(result["error"])
-    finished = any(t in text for t in END_TOKENS)
-    yield text, finished, result.get("n", 0)
+        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
 
 
 # --------------------------------------------------------------------------------------------------------------------
-# Agent loop: mini-swe-agent DefaultAgent + video_coder_harness GuardedAgent semantics, re-implemented without the
-# litellm/vLLM gateway (the model is called in-process).
+# Harness glue (mini-swe-agent DefaultAgent + GuardedAgent semantics)
 # --------------------------------------------------------------------------------------------------------------------
+_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 = 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 = {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["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: 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)
+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": ""}
     try:
-        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."""
+        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 ""
     images = []
 
     def repl(m):
         if m.group(1).strip() != "image_url":
             return m.group(0)
         before = text[: m.start()].rstrip().splitlines()
-        caption = before[-1].strip() if before else ""
-        images.append((caption, m.group(2).strip()))
+        images.append((before[-1].strip() if before else "", m.group(2).strip()))
         return f"[image {len(images)} attached below]"
 
-    return MM_TAG.sub(repl, text), images
+    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
 
 
-def data_url_to_pil(url: str) -> Image.Image:
-    return Image.open(io.BytesIO(base64.b64decode(url.split(",", 1)[1]))).convert("RGB")
+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 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 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 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(workdir: Path) -> str:
-    p = workdir / SCRIPT
+def read_script(ws: Path) -> str:
+    p = ws / HARNESS["script_name"]
     return p.read_text(errors="replace") if p.is_file() else ""
 
 
-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.
+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.
 
     Args:
-        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.
+        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)
     """
     if not prompt or not prompt.strip():
-        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:
+        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)
             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
 
-        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]
+    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 ".")
     else:
-        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.
+        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
 
-    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
 
-    # ---- 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)
+# --------------------------------------------------------------------------------------------------------------------
+# 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}
 
-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())
+Reference Video:
+<Video 1>"""
+
+
+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
+
+    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
 
 
 # --------------------------------------------------------------------------------------------------------------------
 # 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: 1280px; margin: 0 auto; }
+#col-container { max-width: 1300px; margin: 0 auto; }
 .dark .gradio-container { color: var(--body-text-color); }
 """
 
-EXAMPLES = [
-    "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(
-            "# 🎬 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()
+        gr.Markdown(INTRO)
         with gr.Row():
-            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)
+            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")
 
 if __name__ == "__main__":
-    demo.queue().launch(theme=gr.themes.Citrus(), css=CSS, mcp_server=True)
+    demo.queue(default_concurrency_limit=4).launch(theme=gr.themes.Citrus(), css=CSS, mcp_server=True, show_error=True)

harness/guard.py

@@ -0,0 +1,133 @@
+"""Harness-boundary guard and repetition helpers, copied from Video-Coder's video_coder_harness/agent.py
+(GuardedAgent) without the mini-swe-agent dependency. Apache-2.0, https://github.com/CYWang735/Video-Coder"""
+
+import difflib
+import re
+import shlex
+
+
+TOOLS = ("run_blender", "check_script")
+# Shell-level rules: applied to the command with here-document bodies removed, so the Python written into main.py
+# (comments like "frame -> /tmp", "x > 0") is not mistaken for shell redirections or commands.
+_INSPECT = re.compile(rf"^\s*(?:sudo\s+)?(?:type|which|command\s+-v|cat|less|more|head|tail|sed|awk|file|readlink|"
+                      rf"realpath|ls|stat|strings|od|xxd)\b[^;&|]*\b({'|'.join(TOOLS)})\b")
+_ENV_CMD = re.compile(r"(?m)(?:^|[;&|(]|\$\()\s*(?:env|printenv|set|export\s+-p|declare\s+-[px])\s*(?:$|[|;&>)])")
+# writes to an absolute path (redirection, tee, cp/mv/ln target, mkdir/touch), except /dev/null and /dev/std*
+_ABS_WRITE = re.compile(r"(?:(?<![0-9&<])>>?|\btee(?:\s+-a)?|\b(?:mkdir|touch)(?:\s+-p)?)\s*['\"]?"
+                        r"(/(?!dev/(?:null|stdout|stderr)\b)[^\s'\";|&]*)")
+_ABS_TARGET = re.compile(r"\b(?:cp|mv|ln|install|rsync)\b[^\n;|&]*\s['\"]?(/(?!dev/null\b)[^\s'\";|&]+)['\"]?\s*(?:$|[;|&\n])")
+# Whole-text rules (here-document bodies included, so `python3 - <<EOF ... open(...)` is covered too):
+# harness variables and locations that hold credentials or lie outside the task directory.
+_HARNESS_VAR = re.compile(r"\bVCSFT_")
+_SENSITIVE = re.compile(r"(~/|\$\{?HOME\b|/home/|/root/|\.ssh/|\.netrc\b|\.config/|\.env\b|\bOPENAI_API_KEY\b|"
+                        r"\b[A-Z0-9_]*(?:API_KEY|SECRET|TOKEN|PASSWORD)\b|\bsk-[A-Za-z0-9_-]{8,})")
+_HEREDOC = re.compile(r"<<-?\s*(['\"]?)([A-Za-z_][A-Za-z0-9_]*)\1")
+
+
+def strip_heredocs(command: str) -> str:
+    """The shell text of a command without here-document bodies (the delimiter lines are dropped too)."""
+    lines, out, i = command.split("\n"), [], 0
+    while i < len(lines):
+        line = lines[i]
+        out.append(line)
+        i += 1
+        for m in _HEREDOC.finditer(line):
+            while i < len(lines) and lines[i].strip() != m.group(2):
+                i += 1
+            i += 1  # the closing delimiter
+    return "\n".join(out)
+
+
+# Python code (also inside here-documents) that writes to an absolute path.
+_PY_ABS_WRITE = [
+    re.compile(r"""\bopen\(\s*[rbuf]*(['"])(/[^'"]*)\1\s*,\s*[rbuf]*(['"])[^'"]*[wax+][^'"]*\3"""),
+    re.compile(r"""\bPath\(\s*(['"])(/[^'"]*)\1\s*\)\s*\.\s*(?:write_text|write_bytes|mkdir|touch|unlink|rename|replace)\b"""),
+    re.compile(r"""\bos\.(?:makedirs|mkdir|rename|replace|remove|unlink|rmdir)\(\s*(['"])(/[^'"]*)\1"""),
+    re.compile(r"""\bfilepath\s*=\s*[rbuf]*(['"])(/[^'"]*)\1"""),
+]
+_PARENT_DIR = re.compile(r"(?<![\w.])\.\./")
+_SEPARATORS = set("();<>|&")
+
+
+def in_dir(path: str, directory: str) -> bool:
+    """True if `path` is `directory` itself or lies below it ('/w-other' is not inside '/w')."""
+    d = directory.rstrip("/")
+    return bool(d) and (path == d or path.startswith(d + "/"))
+
+
+def _mask_workdir(text: str, workdir: str) -> str:
+    """Replace the task directory by '.' in `text`, but not a longer sibling name such as '<workdir>-other'."""
+    if not workdir:
+        return text
+    return re.sub(re.escape(workdir.rstrip("/")) + r"(?![A-Za-z0-9_.-])", ".", text)
+
+
+def _is_separator(token: str | None) -> bool:
+    return bool(token) and all(c in _SEPARATORS for c in token)
+
+
+def _shell_path_violation(shell: str, workdir: str) -> str:
+    """Rules on shell words: `..` path components and `cd` to somewhere outside the task directory."""
+    text = shell.replace("\\\n", " ").replace("\n", " ; ")
+    try:
+        lex = shlex.shlex(text, posix=True, punctuation_chars=True)
+        lex.whitespace_split = True
+        tokens = list(lex)
+    except ValueError:  # unbalanced quotes etc.: the regex rules still apply
+        return ""
+    for i, tok in enumerate(tokens):
+        if tok == ".." or tok.startswith("../") or "/../" in tok or tok.endswith("/.."):
+            return "it reaches outside the task directory with '..'"
+        if tok in ("cd", "pushd") and (i == 0 or _is_separator(tokens[i - 1])):
+            nxt = tokens[i + 1] if i + 1 < len(tokens) else ""
+            target = "" if _is_separator(nxt) else nxt
+            if not target or target.startswith(("~", "$", "-")):
+                return f"`{tok}` without a path inside the task directory leaves it"
+            if target.startswith("/") and not target.startswith("/dev/") and not in_dir(target, workdir):
+                return f"it changes into a directory outside the task directory ({target})"
+    return ""
+
+
+def harness_violation(command: str, harness_markers: list[str], workdir: str = "") -> str:
+    """Reason why a command crosses the harness boundary, or "" if it is fine."""
+    for marker in harness_markers:
+        if marker and marker in command:
+            return f"it references the harness installation ({marker})"
+    if _HARNESS_VAR.search(command):
+        return "it reads the harness environment variables"
+    m = _SENSITIVE.search(_mask_workdir(command, workdir))  # the task directory itself is fine
+    if m:
+        return f"it references files or variables outside the task directory ({m.group(1)})"
+    if _PARENT_DIR.search(command):
+        return "it reaches outside the task directory with '../'"
+    for pattern in _PY_ABS_WRITE:  # whole text: covers `python3 -c` and here-documents
+        for m in pattern.finditer(command):
+            path = m.group(2)
+            if not (path.startswith("/dev/") or in_dir(path, workdir)):
+                return f"it writes outside the task directory ({path})"
+    shell = strip_heredocs(command)
+    for line in shell.splitlines():
+        if _INSPECT.search(line):
+            return f"it inspects how {', '.join(TOOLS)} are implemented"
+    if _ENV_CMD.search(shell):
+        return "it reads the environment variables"
+    for pattern in (_ABS_WRITE, _ABS_TARGET):
+        for m in pattern.finditer(shell):
+            if not in_dir(m.group(1), workdir):
+                return f"it writes outside the task directory ({m.group(1)})"
+    return _shell_path_violation(shell, workdir)
+
+
+BLOCKED = ("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.")
+REPEAT_WARNING = ("\n\nWARNING: this is the {n}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 ends after "
+                  "{stop} repetitions.")
+
+
+
+
+def _normalize_output(text: str) -> str:
+    return re.sub(r"\d+(?:\.\d+)?", "#", text or "")

harness/teacher.yaml

@@ -0,0 +1,178 @@
+# Teacher trajectory generation: mini-swe-agent (tool-call mode) + OpenAI official API.
+# The system/instance templates below become the SFT prompts, so the student must later run
+# with the same templates. Changing them requires a new output directory.
+
+harness:
+  # Blender version the scripts must target. Set this to the version you will execute/render with
+  # later; the prompt tells the teacher to use exactly this API. Required for non-dry runs.
+  blender_version: "4.5"
+  # true: the agent gets `run_blender` (real execution + render) and a sample is accepted only if the harness
+  # re-executes the final script from scratch and it renders a valid video. false: static checks only.
+  blender_available: true
+  bpy_python: ${WORK}/envs/bpy45/bin/python      # Python 3.11 + bpy 4.5.14
+  bpy_libs: ${WORK}/envs/bpy45-mesa              # libGL/X11 libs + Mesa llvmpipe EGL (Workbench on CPU)
+  exec_timeout: 600                              # seconds per execution, render included
+  summary_samples: 6                             # frames sampled for the scene summary shown to the agent
+  content_samples: 8                             # frames sampled for the empty / static / out-of-view checks
+  # run_blender returns evenly spaced frames of the render as images, so the agent inspects its own result
+  # (needs a video_coder_harness.models.Visual* model class)
+  visual_feedback: true
+  preview_frames: 8
+  preview_width: 640
+  # optional VLM check of the final render (video_coder_harness/judge.py); off: acceptance uses deterministic checks only
+  judge:
+    enabled: false
+    model: openai/gpt-6-astra
+    frames: 8
+    width: 640
+    min_score: 8
+    attempts: 2
+  output_video: output.mp4
+  fps: 24
+  frame_count: 120        # shortest video: 120 frames = 5 s at 24 fps
+  max_frame_count: 240    # longest video: 240 frames = 10 s; the model chooses the length in between
+  resolution: [1280, 720]
+  script_name: main.py
+
+model:
+  # Native Responses API. Do not use `litellm` (Chat Completions): for gpt-6 models litellm bridges it to the
+  # Responses API and drops the function_call items, so every step fails with "No tool calls found".
+  # The Responses path also carries the model's encrypted reasoning across turns.
+  model_class: video_coder_harness.models.VisualResponseModel   # litellm_response + images in tool results (run_blender preview)
+  model_name: openai/gpt-6-astra          # litellm "<provider>/<model id>"; confirm the exact id on your OpenAI account
+  cost_tracking: ignore_errors            # litellm may not know the price of a new model; budget is enforced by max_calls
+  # litellm_model_registry: configs/model_registry.json   # optional: register prices to get real cost numbers
+  model_kwargs:
+    drop_params: true
+    parallel_tool_calls: false            # one command per step gives cleaner trajectories
+    # reasoning_effort: high
+  observation_template: |
+    {%- if output.output | length < 10000 -%}
+    {
+      "returncode": {{ output.returncode }},
+      "output": {{ output.output | tojson }}
+      {%- if output.exception_info %}, "exception_info": {{ output.exception_info | tojson }}{% endif %}
+    }
+    {%- 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 -%}
+  format_error_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 %}
+
+environment:
+  environment_class: local
+  timeout: 900          # per command; run_blender includes a full render
+  env:
+    PAGER: cat
+    MANPAGER: cat
+    PIP_PROGRESS_BAR: "off"
+    TQDM_DISABLE: "1"
+
+agent:
+  step_limit: 30
+  cost_limit: 0          # per-task cost limit is meaningless without price data; use step_limit
+  wall_time_limit_seconds: 1800
+  max_consecutive_format_errors: 3
+  repeat_warn: 3         # warn from the 3rd consecutive near-identical command with the same result
+  repeat_stop: 6         # ... and end the task (exit status RepeatedActions) at the 6th
+  system_template: |
+    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.
+  instance_template: |
+    ## Task
+
+    Write a Blender {{ blender_version }} Python script that builds the following scene and renders it as an animated white-model video:
+
+    <scene_description>
+    {{ task }}
+    </scene_description>
+
+
+    ## Script contract
+
+    - Write exactly one self-contained script: `{{ script_name }}` in the current directory.
+    - It is executed headless as `blender --background --factory-startup --python {{ script_name }}` with Blender {{ blender_version }}, from the directory the video must be written to. Use only the Blender {{ blender_version }} API and the Python standard library; no external assets, files or add-ons.
+    - Start by removing every object in the default scene, then build the scene from scratch.
+    - Geometry: model with primitives, modifiers, `bmesh` or `mesh.from_pydata`. Name objects meaningfully. Keep the total scene under ~500k faces. Objects must not intersect unless the description implies contact.
+    {% if max_frame_count > frame_count -%}
+    - Animation: the video lasts {{ (frame_count / fps) | round | int }}-{{ (max_frame_count / fps) | round | int }} seconds at {{ fps }} fps, i.e. {{ frame_count }}-{{ max_frame_count }} frames; choose the length that suits the action. Set `scene.frame_start = 1` and `scene.frame_end` to that length, and animate with keyframes, drivers, constraints or physics so that the motion described actually happens within that range. Bake any physics simulation before rendering.
+    {%- else -%}
+    - Animation: the video has {{ frame_count }} frames at {{ fps }} fps. Set `scene.frame_start = 1` and `scene.frame_end = {{ frame_count }}`, and animate with keyframes, drivers, constraints or physics so that the motion described actually happens within that range. Bake any physics simulation before rendering.
+    {%- endif %}
+    - Camera: create a camera, assign it to `scene.camera`, and frame the action so that it stays in view for all frames (animate the camera if the description asks for camera motion).
+    - Seed any randomness (`random.seed(...)`) so the result is deterministic. Prefer `bpy.data` / low-level API over `bpy.ops` where the operator needs UI context.
+    - Do not import subprocess, socket, shutil, urllib or similar modules, and do not call os.system/eval/exec.
+
+    ## White-model render (required, at the end of the script)
+
+    Every video in this dataset uses the same look, so configure exactly this and then render:
+
+    - `scene.render.engine = 'BLENDER_WORKBENCH'`
+    - `scene.display.shading`: `light = 'STUDIO'`, `color_type = 'SINGLE'`, `single_color = (0.8, 0.8, 0.8)`, `show_shadows = True`, `show_cavity = True`, `cavity_type = 'WORLD'`. No materials or textures are needed; Workbench studio lighting ignores scene lights.
+    - Resolution {{ resolution[0] }}x{{ resolution[1] }} at `resolution_percentage = 100`, `scene.render.fps = {{ fps }}`.
+    - Output: `scene.render.image_settings.file_format = 'FFMPEG'`, `scene.render.ffmpeg.format = 'MPEG4'`, `scene.render.ffmpeg.codec = 'H264'`, `scene.render.filepath = os.path.join(os.getcwd(), '{{ output_video }}')`.
+    - Last statement: `bpy.ops.render.render(animation=True)`.
+    - Write no other files: no .blend files, images or caches outside the render. Do not quit Blender.
+
+    ## Tools
+
+    {% if blender_available -%}
+    Blender {{ blender_version }} is available through two commands (do not install anything):
+
+    ```bash
+    check_script {{ script_name }}   # fast static check: syntax, bpy import, camera, render call, forbidden calls
+    run_blender {{ script_name }}    # executes the script exactly like the harness and renders {{ output_video }} (CPU, ~20-120 s)
+    ```
+
+    `run_blender` reports the Python traceback if the script fails, whether {{ output_video }} has {% if max_frame_count > frame_count %}{{ frame_count }}-{{ max_frame_count }} frames matching the scene frame range{% else %}{{ frame_count }} frames{% endif %} at {{ resolution[0] }}x{{ resolution[1] }}, and a scene summary: object counts, animated objects, world positions of moving meshes at sampled frames, and meshes whose origin is outside the camera view. Use the numbers to verify that the motion, timing and framing match the description.{% if visual_feedback %} It also returns {{ preview_frames }} frames sampled evenly from the rendered video as images, with their frame numbers and times.{% endif %} It reports a problem when most frames are empty, nothing moves, or no object is in view.
+    {%- else -%}
+    Blender is NOT installed in this environment and must not be installed (no `pip install bpy`, no downloads). You cannot execute the script, so reason carefully about the Blender {{ blender_version }} API: exact operator names, property names and argument names.
+    The only verification tool is the static checker:
+
+    ```bash
+    check_script {{ script_name }}
+    ```
+
+    It checks syntax, required structure (bpy import, camera, render call) and forbidden calls. Passing it does not prove the script runs, so review the code yourself before submitting.
+    {%- endif %}
+
+    ## Workflow
+
+    1. Think & Plan: Before generating any code, explicitly reason about the scene: objects, their dimensions and positions in meters, the motion over time (frame timing), and camera placement/framing.
+    2. Write `{{ script_name }}` with a heredoc: `cat <<'EOF' > {{ script_name }}` ... `EOF`.
+    3. Run `check_script {{ script_name }}` and fix every error.
+    {% if blender_available -%}
+    4. Run `run_blender {{ script_name }}`. Fix every error and problem it reports, and compare the scene summary against the description (positions, timing, clearances, camera framing).{% if visual_feedback %}
+       Then inspect the returned frames one by one against the description and write down every concrete problem you see: missing, unrecognizable or wrongly counted objects; wrong arrangement; motion that is missing, in the wrong order or at the wrong time; objects cut off, outside the frame or too small; objects passing through each other; wrong camera behavior. Fix the problems in the script and run `run_blender` again.{% endif %}
+       Repeat until it reports RUN OK{% if visual_feedback %} and the frames clearly show every element of the description{% else %} and the numbers match{% endif %}. If a command keeps giving the same result, change the script or your approach instead of repeating it; repeated identical commands end the task.
+    5. Submit with `echo COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT` as a command on its own. You cannot continue after that. The harness then re-executes `{{ script_name }}` from scratch; the task only counts if it renders a valid video{% if judge_enabled %} and a reviewer who compares frames of the video against the description confirms that every element it describes (objects, arrangement, motion, camera) is clearly shown{% endif %}.
+    {%- else -%}
+    4. Re-read the script (`nl -ba {{ script_name }}`) and check API usage, coordinates, keyframe timing and camera framing against the description; fix problems with a rewrite or `sed -i`.
+    5. When the script is final and passes the check, submit with `echo COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT` as a command on its own. You cannot continue after that.
+    {%- endif %}
+
+    ## Command rules
+
+    - Each command runs in a fresh subshell in the task directory; `cd` and environment variables do not persist.
+    - Only create or modify files in the current directory.
+    - Use only `check_script` and `run_blender` to check and execute scripts. Do not inspect or modify the harness itself (how these commands are implemented, `VCSFT_*` environment variables, the Blender/bpy installation) and do not run Blender or bpy any other way; such commands are blocked.
+    - For a quick experiment, write a small script in the current directory and run `run_blender experiment.py`: whatever it `print()`s appears in the blender log. Delete experiment files before submitting.
+
+    

packages.txt

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

requirements.txt

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