Tencent trains a 9B model to edit long videos from text at Claude Opus 5 level

The WeChat Vision team at Tencent has presented WeVisCut, an agent that turns a finished narrator script into a long voiceover video, complete with shot breakdown, image selection, narration, music and final assembly. The authors claim that a single compact 9B-parameter model is comparable to Claude Opus 5 in quality while spending noticeably fewer generated tokens per successful minute of video. The comparison ran in the same tool environment, on a new benchmark of 100 tasks.

Why text-to-video editing breaks at the seams

In a long video, every decision depends on the others. Change the duration of one shot and the timecodes of all following shots shift. If an image doesn't fit, you have to search for new material and possibly revise the plan for a whole series of shots. Existing agentic editors typically chain several stages together out of general-purpose large models. But it is unclear how that approach could yield a compact model that holds quality without burning tokens.

The narrator's text itself cannot be changed: the task is to build a video of the required format and length around fixed narration.

How the agent's environment works

The model runs inside a harness with a shared project state. The state records which parts of the text are covered, the order of the shots, which files have already been created and which problems remain. What was planned and what was actually done are recorded separately.

The model plays three roles:

• the orchestrator chooses the tool and its arguments; • the generator produces structured content, such as text for a shot's design; • the critic inspects the result and demands or verifies fixes.

The tools cover the whole cycle: splitting the text into segments, shot planning, visual search, speech synthesis, templates for accent shots, background music search, timeline assembly, rendering, quality checks, repair and final stitching. The order is not hard-coded: the model picks the next step based on the current state.

The environment validates every call. If the model requests stitching without finished shots or music, the environment returns a "blocker" listing what is missing, and the orchestrator first produces the missing pieces. For accent shots, a visual judge model scores the quality. Fixes are targeted: if the design was corrected, the narration is not regenerated. The number of repair attempts is limited, but the limit does not waive the delivery requirements: without the required files, the final video does not count.

How finished videos became training data

A finished video stores only the spoken lines and the shot structure, not the tool calls, errors and fixes. So the authors built a four-step pipeline on 3 750 Bilibili videos (technology and digital products, business and finance, natural sciences, social sciences and humanities):

• Plan reconstruction. The pipeline extracts timestamped lines, the shot structure and the mapping of each sentence to a shot. The result is a storyboard, not a record of the original editor's actions. • Verified run. The storyboard is executed with the same tools used in production. The environment checks file references, audio durations, template inputs, timeline positions and the final render. • Inspection and repair. If defects show up during the run, they are fixed in a targeted way, and the successful artifacts are kept. • Example assembly. The records of calls, responses and fixes are sorted by role into training examples.

The result is more than 130 thousand examples.

Training and evaluation

Training runs in two stages. First comes unified fine-tuning on the examples, plus fine-tuning on selected successful runs verified by the environment; this is how the model learns the tools and how to recover from failures. Then comes Guided-OPD: teacher and student take turns acting, and the teacher's intervention is gradually phased out, so the model learns from states it reached on its own. After that, rewards are compared only within the same role and the same context.

The benchmark includes 100 tasks and five metrics: accuracy in following the text, match between image and narration, execution of the plan on time, long-range consistency, and the share of successfully delivered videos. The metrics tie the video to the script and the plan, not just to whether the render succeeded.

The system beats its base model and outperforms specialized editors built for the same task. An earlier work on the Crayotter environment also trained a 9B model, but it used preferences over the final video and hand-written tasks. Here the model learns from executable trajectories.

For engineers, the takeaway is this: an environment that validates every step and records errors produces training data, not just protection against failures. For business: a small model in the right environment can replace an expensive general-purpose API in mass production of explainer videos. The code, project page and weights are published on GitHub and Hugging Face.