betaFeedback

WorksComputer Science

VIVID: A Visual Harness for Agentic Video Editing

Abstract

Video editing requires agents to make editing decisions grounded in audiovisual observations and precise temporal localization, and to evaluate their effects in rendered outputs. General-purpose coding agents possess strong comprehension, reasoning, and code execution capabilities, while media interaction and evidence management mechanisms tailored to video tasks can further unlock their editing potential. We introduce VIVID, a visual harness that supports multiple native coding agents in video post-production without additional model training. VIVID provides tools for on-demand video inspection, audio analysis, and transcription, and preserves observations alongside their corresponding media versions and temporal coordinates. Agents can actively retrieve these observations as they reason, perform edits using their native coding and shell tools, and inspect rendered outputs to guide subsequent revisions. On AgenticVBench, comprising 100 tasks across Assembly, Repair, Sequencing, and Repurpose, Codex with VIVID achieves an average score of 58.6%, an improvement of 20.2 percentage points over native Codex. The same harness also integrates with Claude Code and OpenCode, achieving average scores of 55.1% and 37.1%, respectively, both substantially exceeding their native baselines. These results highlight VIVID's potential as a reusable visual harness for extending the capabilities of general-purpose coding agents to video editing.

Code: https://github.com/yuwenhan07/VIVID

Introduction

Video editing requires editors to understand source materials, select appropriate content, and transform it into a work that meets the task requirements through cutting, sequencing, and audiovisual adjustments [9, 10, 21]. This process calls for continual observation and judgment: whether a shot fits the narrative, where a line of dialogue should end, and whether

captions align with the image and sound all depend on the underlying audiovisual content. Editors must also inspect the rendered video, as a well-reasoned editing plan does not always translate into a correct output. They therefore need to review the result and revise it when necessary.

General-purpose coding agents possess language understanding, reasoning, and code execution capabilities. With support from an external harness, they can invoke media tools to perform operations such as cutting, concatenation, and captioning, providing a foundation for automated video editing [1, 6, 15, 23, 33]. Prior work has explored specialized editing workflows, role collaboration, and the management of intermediate artifacts to support video production [17, 29]. AgenticVBench further evaluates agents on real-world post-production tasks [2]. These advances raise a question: how can appropriate media interaction interfaces further unlock the video editing capabilities of general-purpose coding agents while preserving their native tools and execution environments?

A central challenge is that the evidence needed for editing changes as reasoning and editing progress. An initial overview may reveal candidate shots but provide insufficient detail to determine precise cut boundaries. Likewise, an earlier description of the content may omit details needed to adjust captions or repair audiovisual synchronization. Research on active video understanding and visual memory suggests that agents can select observations according to their current questions and revisit existing evidence when needed [5, 13, 26, 27, 34]. Video editing further requires this evidence to be associated with specific media versions and temporal positions: cutting, reordering, and speed changes alter where content appears in the output, while successive renders produce different versions. Agents therefore need traceable connections among source observations, editing decisions, and output inspection.

As shown in Figure 1, we introduce VIVID, a visual harness for agentic video editing. VIVID provides native coding agents with on-demand audiovisual observation, persistent evidence, and output inspection. These capabilities allow agents to locate relevant content, retrieve observations associated with media versions and temporal coordinates, and revise edits based on rendered results. Agents can choose their own observation and editing strategies, using either native tools or VIVID’s optional editing interface, without additional model training or updates. On the 100 tasks of AgenticVBench, Codex, Claude Code, and OpenCode with VIVID achieve average scores of 58.6%, 55.1%, and 37.1%, improving upon their respective native configurations by 20.2, 22.7, and 9.7 percentage points. Ablation studies and trajectory analysis further support the value of media tools and evidence management, and show improvements in content selection, temporal localization, and consistency between editing plans and outputs. These results demonstrate that VIVID can extend the video editing capabilities of general-purpose coding agents.

Figure 1. Overview of VIVID, a visual harness for agentic video editing. VIVID augments native harnesses with on-demand audiovisual inspection, persistent evidence memory and retrieval, and output inspection and revision to support iterative editing from source footage to rendered video.

Our contributions are summarized as follows:

  • We introduce VIVID, which integrates on-demand audiovisual observation, persistent evidence associated with media versions and temporal coordinates, and output inspection into the video editing workflows of native coding agents.

  • We demonstrate the effectiveness of VIVID on AgenticVBench, improving editing performance across three model–harness configurations without additional model training.

  • We analyze VIVID’s performance gains, execution behavior, and computational overhead through ablation studies, tool-call and token-consumption analyses, editing trajectories, and case studies.

Related Work

Agentic video editing

Computational video editing combines source material understanding with editorial decision-making, spanning tasks such as dialogue-scene assembly, transcript-based editing, and language-guided timeline manipulation [9, 10, 20, 21]. Recent work further explores how specialized models and agentic workflows can follow natural-language instructions to produce coherent video edits [4, 16, 17, 34].

For example, EditDuet coordinates an Editor and a Critic for nonlinear editing, while VideoAgent combines shot planning with specialized editing agents [17, 34]. Other systems address long-form video editing through semantic indexing, inspectable production artifacts, or learned editing policies [4, 14, 28, 29]. AgenticVBench evaluates agents’ ability to complete video post-production tasks through assignments involving Assembly, Repair, Sequencing, and Repurpose [2]. VIVID supports video post-production by extending existing coding agents with media interaction capabilities, without updating the underlying model parameters, while allowing agents to choose how to observe and edit.

Agent interfaces and editing harnesses

The interface between an agent and its execution environment influences how the agent observes its surroundings, uses tools, and carries out multistep tasks [7, 22, 25, 30, 31]. In video editing, Crayoter preserves intermediate production artifacts and execution traces to support inspection and repair of the editing process [28, 29]. Other systems incorporate feedback and local revision into their editing workflows [3, 32]. VIVID explores a visual harness that combines audiovisual inspection and evidence retrieval with the native tools and execution environments of coding agents. It supports source observation, output inspection, and verification, helping agents make more accurate editing decisions.

Active video understanding

Video understanding agents use selective observation and memory mechanisms to reason over long videos [24]. The VideoAgent systems explore iterative frame retrieval and structured multimodal memory, respectively [5], while VideoTree and LensWalk adapt the temporal scope or granularity of observation to the current query [12, 27]. Other work investigates how to preserve visual observations or construct reusable memory for subsequent reasoning [8]. These works primarily focus on video understanding [11, 18]. VIVID brings active observation and persistent evidence into a video editing workflow, allowing agents to select what to inspect based on the current task and use observations associated with media versions and temporal coordinates to guide subsequent edits and output inspection. This supports more precise video segment localization and editing decisions.

Method

Video editing requires an agent to understand source materials, localize relevant segments, and inspect the actual output after editing. Because edits change the temporal positions of content and multiple rounds of editing can produce different media versions, the agent needs to revisit evidence associated with specific versions and time coordinates to support subsequent decisions and review.

To this end, we introduce VIVID, a set of extensions to native agent harnesses for video editing. Given a task brief and source materials, VIVID augments the native harness with on-demand audiovisual inspection, persistent evidence memory and retrieval, and output inspection and revision. These capabilities preserve the native harness’s execution environment and the agent’s control over its editing strategy. The agent decides what to inspect, how to perform edits, and when to review the output, while VIVID maintains traceable observations across the process. The method requires no additional training or updates to the underlying model.

Core Components of VIVID

On-demand audiovisual inspection. As shown in Figure 2(a), VIVID allows the agent to select the temporal range and spatial region to inspect based on the current question. For video, the agent can first request a sparse overview across time, then sample frames or crop regions within candidate segments. It can also compare sampled frames from multiple source files, with filenames and timestamps, to support shot selection and ordering. Each observation includes images together with their media version, actual frame timestamps, and crop information, allowing visual judgments to be associated with specific positions in the source material.

Figure 2. VIVID’s core components and iterative editing workflow. The agent inspects media on demand, retains version-linked evidence for retrieval, and reviews rendered outputs to guide revisions.

Consider a visual inspection request specifying a media version vv, a time range II, and an optional spatial region RR. Let T={t1,…,tm}T = \{t_1, \ldots, t_m\} be the timestamps of the frames actually returned. The observation can be represented as

Ovis(v,I,R)={(tj,Crop⁡(Decode⁡(v,tj),R))}j=1m.(1)O_{\mathrm{vis}}(v,I,R) = \left\{ \left(t_j,\operatorname{Crop}(\operatorname{Decode}(v,t_j),R)\right) \right\}_{j=1}^{m}. \tag*{(1)}

Here, tjt_j is the time coordinate of the returned frame. When no region is specified, Crop retains the full frame.

For audio, VIVID can extract an audio window, provide amplitude statistics, waveforms, and spectrograms, and use speech recognition to produce segment-level text or estimated word-level timestamps. The agent can combine visual observations and transcripts to locate dialogue and then inspect potential cut points. This design allows the agent to choose the scope and granularity of inspection for the question and examine details as needed, supporting segment selection, temporal localization, and review of the final output.

Persistent evidence memory and retrieval. During editing, the agent may revisit the same segment or reconsider an earlier judgment after producing multiple versions. VIVID therefore stores acquired observations outside the model’s current context, as shown in Figure 2(b). The system assigns identifiers to media versions and associates each observation with its corresponding version, time coordinates, and evidence identifier. When the contents of a file change at the same path, existing evidence remains linked to the version from which it was obtained. This allows the agent to distinguish content across versions and revisit the observations underlying earlier decisions.

The agent can search indexed transcripts and other recorded text to locate relevant evidence, or revisit a saved observation through its evidence identifier. Version and time links support revisiting earlier judgments without confusing evidence from different media versions.

Output inspection and revision. After rendering, VIVID treats the actual output as an object of inspection, as illustrated in Figure 2(c). The agent can review its visuals, audio, and captions, focusing on intervals around cuts or task-specific requirements. The agent combines format and decoding checks with audiovisual review of the output to guide revision. When an issue is found, the agent can revisit relevant source evidence, revise segments, captions, or processing parameters, and render and inspect a new output. This feedback connects editing decisions to their effects in the rendered media.

Iterative Editing Workflow

As illustrated in Figure 2(d), the agent can examine source materials according to the task brief and develop a candidate editing plan using video overviews, local views, or transcripts. During reasoning, it can retrieve earlier evidence, request additional observations, or record unresolved questions. It then implements the plan and renders an actual media file for output inspection.

Output inspection and revision connect the rendered result to subsequent editing decisions. The agent can review the output, return to relevant source evidence, revise its plan, and render again before delivering the task-required files. Observation, reasoning, editing, and review can be interleaved according to the agent’s strategy. Persistent task state and integration with the native harness support this workflow.

Persistent task state. In addition to media evidence, VIVID preserves the original task brief and allows the agent to record its understanding of the materials, editing plan, and unresolved questions. Task notes retain this working state, while an automatically maintained index provides navigation to media versions and evidence. Together with the preserved workspace, they make prior requirements, decisions, and observations accessible when work resumes in a fresh context. Continuation requires reconciling the recorded state with current artifacts and unfinished processing jobs, so that subsequent decisions reflect the actual execution state. The cumulative task budget carries over.

VIVID with the native harness. VIVID extends the native harness while preserving the agent’s choice of how to implement edits. The agent can use the native execution environment for specialized transformations and VIVID’s optional editing support for explicitly declared operations such as trimming, concatenation, constant-speed changes, and caption placement. For declared edits, source–output time mappings connect positions on the declared output timeline to the corresponding source intervals, supporting source tracing during revision and the projection of source-time captions onto the output timeline. Supplementary material provides implementation details.

Experiments

Experimental Setup

We evaluate VIVID on AgenticVBench, a benchmark comprising 100 video post-production tasks across four categories: Assembly, which requires selecting and assembling shots; Repair, which requires correcting timing or audiovisual defects; Sequencing, which requires restoring the order of clips; and Repurpose, which requires adapting footage according to editing instructions. We retain the benchmark’s original task inputs and task-specific evaluation methods for the final videos.

The experiments cover three model–harness configurations: GPT-5.6-sol with Codex, Claude 5 with Claude Code, and GPT-5.5 with OpenCode. Additionally, we evaluate GPT-5.6-sol in Craytoter [29], a harness specifically designed for long-horizon video editing tasks, to provide an additional same-model comparison. For the three primary configurations, VIVID extends each native harness with interfaces for media inspection, transcription, evidence retrieval, editing assistance, and output validation, while retaining the native shell and programming tools. VIVID does not train or update the underlying models; instead, it extends and improves the harness. Each task is run independently three times for each model–harness configuration under a fixed tool schema, with identical task inputs and matched rollout limits (Supplementary Material). We follow AgenticVBench’s task-specific scoring protocols, including its chance-adjusted Assembly score. Runs that produce no usable output are assigned a score of 0.

Main Results

Table 1 summarizes the main performance comparisons between native harnesses and their VIVID-integrated counterparts, alongside results for a selection of open-source and closed-source models and harnesses.

ModelHarnessAverage (%)Δ\DeltaRepurposeSequencingRepairAssembly
Human Experts–88.5–95908881
Qwen3.8-Omni-FlashClaude Code [19]36.8–––––
GPT-5.5Codex [2]31.0 ± 4.0–30263038
Gemini 3.1 ProOpenCode [2]23.8 ± 3.7–23192033
Crayotter-9BCrayotter env. [29]15.7–237.915.214
Qwen3.5-397B-A17BCrayotter env. [29]10.9–15.38.19.67.5
Seed 2.0 LiteClaude Code [19]10.0–––––
GPT-5.6-solCrayotter env.33.7 ± 2.9–30342353
Codex [2]38.4 ± 6.3–34333948
Codex + VIVID58.6 ± 3.8+20.258↑24^{\uparrow24}58↑25^{\uparrow25}43↑4^{\uparrow4}77↑29^{\uparrow29}
Claude Fable 5Claude Code [2]32.4 ± 5.1–29233146
Claude Code + VIVID55.1 ± 3.6+22.756↑27^{\uparrow27}59↑36^{\uparrow36}37↑6^{\uparrow6}66↑20^{\uparrow20}
GPT-5.5OpenCode [2]27.4 ± 3.5–27202737
OpenCode + VIVID37.1 ± 3.5+9.735↑8^{\uparrow8}41↑21^{\uparrow21}270^{0}46↑9^{\uparrow9}

Table 1. Performance of different model–harness configurations on AgenticVBench. All scores are percentages. Values reported with ± indicate the mean and standard deviation over three independent runs. Results from prior work are cited in the corresponding rows. “–” indicates that a result is unreported or not applicable. Δ\Delta and blue superscripts indicate percentage-point gains over the corresponding native harness for the overall average and each task category, respectively. Bold entries indicate VIVID-augmented configurations.

With VIVID, Codex, Claude Code, and OpenCode achieve overall average scores of 58.6, 55.1, and 37.1, respectively, representing gains of 20.2, 22.7, and 9.7 percentage points over their respective native configurations. Scores improve across all task categories for Codex and Claude Code. For OpenCode, they improve on Repurpose, Sequencing, and Assembly and remain unchanged on Repair. These results demonstrate that VIVID can be integrated with diverse native harnesses and consistently improves overall performance across all three evaluated model–harness configurations. In an additional same-model comparison using GPT-5.6-sol, Codex + VIVID achieves a score of 58.6, outperforming native Codex and Crayotter, which score 38.4 and 33.7, respectively, further highlighting the performance advantages of the VIVID-integrated system across different harness environments.

Across task categories, Assembly achieves the highest average score within each of the three configurations, while the improvement on Repair is relatively limited. Comparing configurations, Claude Code achieves the highest average score of 59 on Sequencing, while Codex performs best on Repair and Repurpose, with average scores of 43 and 58, respectively. The model–harness configurations also differ in how they invoke and use the interfaces introduced by VIVID, and their performance gains vary. In § 5, we further analyze agent behavior and interface usage to investigate how these differences relate to performance improvements.

Ablation Study

To examine the contributions of the three core components introduced in § 3, we compare full VIVID with three variants using GPT-5.6-sol with Codex. Each variant removes one core component:

  • w/o on-demand audiovisual inspection: Disables VIVID’s task-directed inspection of source video and audio, including frame sampling, spatial-region inspection, and audio analysis. These observations support content selection and the localization of relevant source intervals.

  • w/o persistent evidence memory and retrieval: Removes VIVID’s persistent evidence records, memory index, and retrieval support, together with the files used to retain task requirements, editing plans, and working notes. These records support task continuation and evidence reuse across editing iterations.

  • w/o output inspection and revision: Disables VIVID’s audiovisual review and technical checks of rendered outputs. This removes the output feedback used to identify editing issues and guide further revision.

As shown in Table 2, full VIVID achieves an average score of 58.6. Removing on-demand audiovisual inspection reduces the score to 42.6, a decrease of 16.0 percentage points. Removing persistent evidence memory and retrieval reduces it to 47.8, a decrease of 10.8 percentage points. Removing output inspection and revision reduces it to 44.0, a decrease of 14.6 percentage points. Full VIVID outperforms all three variants across every task category.

ConfigurationAvg.RepurposeSequencingRepairAssembly
Full VIVID58.657.757.943.077.1
w/o on-demand inspection42.646.039.936.046.8
w/o evidence memory47.854.447.422.959.9
w/o output review44.046.348.326.749.8

Table 2. Ablation of VIVID’s three core components using GPT-5.6-sol with Codex on AgenticVBench.

On-demand audiovisual inspection produces the largest average performance drop when removed, with Assembly decreasing from 77.1 to 46.8. Removing persistent evidence memory and retrieval has its largest category-level effect on Repair, which decreases from 43.0 to 22.9. Removing output inspection and revision also substantially reduces Assembly and Repair scores, to 49.8 and 26.7, respectively. Together, these results support the contributions of acquiring audiovisual evidence, retaining evidence and task state across iterations, and using output feedback to guide revision.

Model–Harness Behavior Analysis

Tool Call Behavior

Figure 3 summarizes the task coverage of VIVID’s six tools across the three model–harness configurations. We relate these usage patterns to the core components introduced in § 3.

Figure 3. VIVID tool-use coverage across task categories and model–harness configurations. Each cell reports the percentage of task runs that invoke the corresponding tool at least once. Darker colors indicate higher coverage.

On-demand audiovisual inspection. The inspect tool is used in 44–100% of tasks across the reported categories and configurations. Transcription coverage varies with task requirements: no configuration invokes transcribe for Assembly, while its coverage reaches 68–82% for Sequencing and 67–92% for Repurpose. This pattern is consistent with agents selecting visual and linguistic evidence according to the editing task, as supported by on-demand audiovisual inspection.

Persistent evidence memory and retrieval. The retrieve tool is used across all four task categories, with coverage of 10–13% for Assembly, 28–32% for Repair, 23–28% for Sequencing, and 27–31% for Repurpose. The similar coverage across configurations within each category shows that evidence retrieval is used across different native harnesses, supporting the role of persistent memory in making recorded observations accessible during editing.

Output inspection and revision. The verify interface is invoked in 56–100% of tasks across categories and configurations. It provides file and decoding checks and output review planning, complementing audiovisual inspection through inspect. These calls show that agents use VIVID’s technical checking support during task execution. § 6.2 further examines how inspection of rendered outputs informs subsequent revisions.

Token Consumption and Performance Gains

To measure the inference overhead of VIVID, we compare token consumption and task scores for the three model–harness configurations with and without VIVID. Figure 4 shows the total token consumption per 100 tasks and the corresponding average score. With VIVID, both token consumption and task scores increase across all three configurations.

Figure 4. Token consumption and editing performance with and without VIVID. The x-axis shows total token consumption per 100 tasks, and the y-axis shows the average task score. Dashed lines connect each native model–harness configuration to its VIVID-augmented counterpart. Lighter and darker markers indicate the native and VIVID-augmented configurations, respectively.

Specifically, GPT-5.6-sol with Codex uses 17.9% more tokens and improves its average score from 38.4 to 58.6, a gain of 20.2 percentage points. Claude Fable 5 with Claude Code uses 10.7% more tokens and improves its score from 32.4 to 55.1, a gain of 22.7 percentage points. GPT-5.5 with OpenCode uses 53.3% more tokens and improves its score from 27.4 to 37.1, a gain of 9.7 percentage points.

Behavior Across Harnesses

The Codex and Claude Code configurations make more selective use of VIVID’s tools. As discussed in § 5.1, inspection and transcription have high coverage in Sequencing and Repurpose, while some other interfaces are used in fewer tasks. Both configurations also achieve larger performance gains with smaller increases in token consumption (§ 5.2). Together, these observations suggest more efficient integration of VIVID’s tools with native capabilities, with agents drawing on media-specific support according to editing needs.

The OpenCode configuration makes broader use of some VIVID interfaces, particularly catalog, which is used in 98.9% of its tasks. This pattern suggests a stronger tendency to adopt VIVID-provided interfaces across tasks. Its broader interface use is accompanied by a larger increase in token consumption and a smaller performance gain, yielding a less favorable balance between token overhead and score improvement in these experiments.

Across these different tool-selection patterns, VIVID improves the average task score for all three configurations: by 20.2 percentage points with Codex, 22.7 with Claude Code, and 9.7 with OpenCode. These consistent gains support the effectiveness of VIVID’s design across the tested native harnesses. Its combination of on-demand audiovisual inspection, persistent evidence memory and retrieval, and output inspection and revision accommodates different agent workflows while improving editing performance.

Trajectory Analysis

Analysis of Editing Processes and Outcomes

For each task, we randomly select one of three runs from native Codex and Codex + VIVID. Three hired video editing experts judge each trajectory against the applicable criteria for seven features: content selection, temporal localization, global ordering, visual composition, audiovisual alignment, repair quality, and plan–output consistency. Table 3 reports the percentage of applicable assessments that satisfy each criterion.

FeatureCodex (%)Codex + VIVID (%)
F1 Content selection32.657.0
F2 Temporal localization43.069.0
F3 Global ordering and narrative21.438.1
F4 Composition and subject visibility45.862.5
F5 Audiovisual alignment29.445.1
F6 Repair and editing effects60.066.7
F7 Plan–output consistency81.196.2

Table 3. Feature-level comparison of native Codex and Codex + VIVID. Each value reports the percentage of applicable evaluations satisfying the corresponding criterion.

Content selection and temporal localization. With VIVID, the satisfaction rates for content selection (F1) and temporal localization and edit boundaries (F2) increase by 24.4 and 26.0 percentage points, respectively. Both require the agent to ground editing decisions in source observations: it must identify relevant content and locate the target events or defects. VIVID provides on-demand video inspection, local visual observations, and audio transcription, allowing the agent to obtain audiovisual evidence with temporal coordinates around candidate segments. These improvements are consistent with the intended role of inspection in supporting content selection and temporal localization.

Global narrative and audiovisual coordination. The satisfaction rates for global ordering and narrative coherence (F3) and for audio, captions, and audiovisual alignment (F5) increase by 16.7 and 15.7 percentage points, respectively. These requirements involve integrating information across clips or modalities: the former requires reasoning about ordering and narrative relationships, while the latter requires coordinating visuals, sound, and captions. VIVID’s persistent evidence memory and retrieval component links audiovisual observations to media versions and temporal coordinates, allowing agents to revisit relevant evidence during editing. The same evidence can thus inform successive editing decisions. These gains are consistent with the component’s role in supporting cross-clip and cross-modal judgments.

Visual composition and repair quality. The satisfaction rates for visual composition and subject visibility (F4) and for repair and editing effects (F6) increase by 16.7 and 6.7 percentage points, respectively. VIVID allows agents to inspect the visual and audio content of rendered outputs, providing feedback that can help identify problems such as subject cropping, poor framing, or insufficient repair. The improvement in F4 is consistent with the value of output inspection for visual composition. The smaller improvement in F6 also suggests that observation and verification need to be combined with effective processing methods, such as denoising, detail restoration, or color correction.

English captions and using only the source footage. The supplementary material presents additional case studies.

Consistency between the editing plan and the output. The satisfaction rate for plan–output consistency (F7) increases by 15.1 percentage points. This criterion evaluates whether the rendered output follows the editing plan. VIVID allows the agent to inspect rendered outputs, identify discrepancies with its plan, and revise the edit. For edits declared through VIVID, source–output time mappings link positions on the declared output timeline to the corresponding source intervals, supporting source tracing during output review and revision.

Overall, Codex + VIVID achieves higher satisfaction rates than native Codex across all seven features, with particularly large improvements in content selection and temporal localization. These results support VIVID’s design of connecting source inspection, editing decisions, and output review through on-demand audiovisual evidence associated with media versions and temporal coordinates. At the same time, global narrative, audiovisual coordination, and repair quality remain areas for further improvement.

Case Study: Speech Highlight Editing

To further examine how VIVID supports the editing process, we study a Repurpose task based on Greta Thunberg’s UN climate speech, as shown in Figure 5. The task requires the agent to condense a complete long-form speech into a concise highlight, preserving the key arguments, original narrative order, and speaker’s voice while adding readable English captions and using only the source footage.

Figure 5. Comparison of native Codex and Codex + VIVID. (a) Sampled frames from the final outputs show differences in aspect ratio and caption visibility. (b1–b2) Examples of inspection and revision with VIVID. (c) Rubric scores summarize the differences between the two outputs.

Final outputs. As shown in Figure 5(a), both configurations retain key moments from the speech, including the opening, the criticism of empty promises and economic growth, and the closing statement. They differ, however, in visual presentation and captions. In the native Codex output, some frames exhibit aspect-ratio distortion, and no caption is visible at one sampled time point. In the displayed Codex + VIVID frames, the speaker’s proportions appear natural and the captions are visible. The evaluator assigns the two outputs scores of 0.21 and 1.00, respectively. Most of the difference comes from the audio, captions, and constraints category, in which the native output incurs a missing-caption penalty.

Inspection and revision. The Codex + VIVID trajectory shows that, after producing an initial render, the agent inspected an overview of the output and several specific time windows, then revised the captions and rendered the video again. During a subsequent review, the agent identified excessive repetition of the speech’s signature challenge. It adjusted the edit and captions, using the recovered time to retain a complete statement about climate risk. After the revision, the agent inspected local windows again and checked the technical properties of the final file. This process illustrates how VIVID supports a render–inspect–revise workflow, allowing the agent to review specific intervals and make subsequent adjustments.

Conclusion

We presented VIVID, a visual harness that extends general-purpose coding agents to video editing. VIVID equips agents with on-demand audiovisual inspection, persistent evidence memory linked to media versions and temporal coordinates, and inspection of rendered outputs, enabling an iterative workflow of observation, reasoning, editing, and review while preserving their native tools and autonomy over editing decisions. Experiments on AgenticVBench show that VIVID consistently improves editing performance across diverse model–harness configurations without additional model training, and ablation studies confirm the effectiveness of each core component. These results demonstrate that grounding editing decisions in actively acquired, persistently retained, and revisitable audiovisual evidence is an effective path toward reliable and practical agentic video editing.

Method Details

This section supplements § 3 with implementation details of VIVID’s three core components: on-demand audiovisual inspection, persistent evidence memory and retrieval, and output inspection and revision. It then describes persistent task state and VIVID’s integration with the native harness, including optional editing and declared time mapping, as supporting mechanisms for the iterative editing workflow.

VIVID exposes these capabilities through six default tools, defined in Table 4. The tools support the core components and workflow alongside the native harness’s file, shell, and code-execution tools. The agent retains control over what to inspect, how to implement edits, and when to review the output.

ToolDefinition
catalogBrowse source materials, registered media versions, and their media properties.
inspectInspect video and audio on demand within specified time ranges or spatial regions, and compare multiple assets.
transcribeTranscribe a specified audio interval with segment-level or estimated word-level timing.
retrieveSearch indexed text or revisit saved observations with their media-version and time references.
editOptionally trim, concatenate, and change the speed of clips, process subtitles, compute declared mappings between source and output time, and manage native command jobs.
verifyCheck files, media properties, and decoding status, and plan output review windows based on a timeline or time-referenced requirements.

Table 4. VIVID’s six default tools and their definitions.

Core Task Prompt

VIVID prepends the following task prompt, lightly edited here for presentation, to the complete original task brief and the current persistent state, including the workspace, budget, continuation status, and recovery information. The prompt preserves the agent’s choice of editing methods while distinguishing sampled observations and technical checks from evidence of content quality.

Listing A.1: Core Task Prompt

Complete the original task using your native tools and any useful VIVID media tools. The original task brief governs source permissions, constraints and deliverables. Keep supplied sources unchanged.

VIVID’s optional media helpers are described by the tool schemas. Use native tools and choose your own editing methods; no plan registration or VIVID execution is required.

Sampled frames are not continuous coverage. A transcript or spectrogram is not proof of listening. Technical checks do not establish content quality. …

TASK.md preserves the brief. GUIDE.md and WORK-ING.md are optional native-file notes; MEMORY.md indexes archived evidence.

When a fresh session is necessary, update notes and end with VIVID_CHECKPOINT. On continuation, inspect actual files and pending jobs. Report delivered files and any unverified requirements.

On-demand Audiovisual Inspection

VIVID does not require the agent to view an entire video at once and retain all relevant content in its context. Instead, it allows the agent to select what to observe as its questions evolve. The agent can request video frames from a temporal window, crop a spatial region, or compare locations across assets. Contact sheets retain asset identities and the timestamps of the decoded frames. For longer material, the agent can begin with a sparse overview and then inspect candidate intervals in greater detail. For a local question, it can sample directly within a shorter window, as shown in Figure 6.

Figure 6. Video sampling in short and long windows. (a) A small number of frames are sampled within a short window to examine local changes in an action. (b) Frames are sampled across a long window to provide a sparse overview of different temporal locations.

The same principle applies to audio. The agent can inspect a selected audio window through amplitude statistics, waveforms, or spectrograms, and request transcription with segment-level or estimated word-level timestamps. Longer transcription requests may be processed in chunks, allowing completed intervals to be retained even when later intervals remain pending.

Persistent Evidence Memory and Retrieval

For an observation to remain useful throughout an editing task, the agent must be able to recover it and identify its origin. VIVID therefore stores acquired observations outside the current model context and associates them with evidence identifiers, media versions, temporal coordinates, and observation types. The current implementation identifies a registered version using the file’s workspace-relative path and content hash.

This distinction is particularly important when a file is rewritten at the same path. Previously archived observations remain associated with the version from which they were obtained, while newly registered content receives its own version identity. The agent can therefore revisit an earlier observation without confusing it with the file’s current contents.

The agent can retrieve evidence by identifier or search indexed transcripts, notes, and other records, narrowing results by asset, time range, or evidence type.

Output Inspection and Revision

VIVID reuses on-demand audiovisual inspection to examine the actual rendered output and combines these observations with technical checks to support revision. The verification interface checks file identity, media properties, decoding status, and specified format requirements. Given a declared timeline, subtitles, or task requirements with output-time coordinates, the system can also suggest review windows, including windows around cut points.

The agent can use the observation interface to inspect the actual output and revisit source evidence as needed. If it finds a problem, it can revise the plan, render again, and inspect the new file.

Persistent Task State

VIVID uses files to preserve task requirements and working state for context continuation. TASK.md stores the original task requirements. The agent can record relatively stable interpretations of the material and editing constraints in GUIDE.md, and the current plan, unresolved issues, and next actions in WORKING.md. MEMORY.md is an automatically generated bounded index that provides navigation to media versions and recent evidence.

When a task needs to continue in a new context, the agent can resume work using the original requirements, notes, index, preserved workspace, and archived evidence, and revisit specific observations as needed. The cumulative task budget carries over rather than resetting at continuation. Notes represent a revisable working understanding and should be checked against the actual files, evidence, and job status when work resumes. For unfinished media-processing jobs, the agent should first inspect the actual process, outputs, and logs before deciding whether to continue waiting, cancel, or rerun the job.

VIVID with the Native Harness

VIVID preserves the agent’s choice of how to implement edits. The agent can use the native harness’s shell and code-execution tools with Python, FFmpeg, and other available programs, or use VIVID’s optional editing support for explicitly declared trimming, concatenation, constant-speed changes, and caption operations. Specialized repair and visual effects can therefore continue to use the native execution environment.

Declared time mapping. VIVID’s optional editing interface allows the agent to declare a sequence of source intervals and their constant playback speeds. From these declarations, the system computes the correspondence between the declared output timeline and the source intervals. Consider a sequence of concatenated segments. Let segment ii be taken from the source interval [ai,bi)[a_i,b_i), played at speed ri>0r_i > 0, and placed at output start time oio_i. In ideal continuous time, an output time tt within this segment maps to the source time

τi(t)=ai+ri(t−oi),(2)\tau_i(t) = a_i + r_i(t - o_i), \tag*{(2)}
t∈[oi,oi+bi−airi),(3)t \in\left[o_i, o_i + \frac{b_i-a_i}{r_i}\right), \tag*{(3)}
oi=∑j<ibj−ajrj.(4)o_i = \sum_{j<i}\frac{b_j-a_j}{r_j}. \tag*{(4)}

This correspondence allows the agent to trace a position on the declared output timeline back to the relevant source segment and project source-time captions onto the output timeline. It can support source tracing when revising an output.

Rendering and caption handling. The agent can render the declared clips and subtitles through VIVID or implement edits through the native execution environment. For subtitles crossing a cut boundary, VIVID’s managed rendering uses available word-level timestamps to determine the retained text. Entries whose retained text cannot be determined are flagged for subtitle revision or additional timing information.

Experiment Details

This appendix describes the experimental setup for evaluating VIVID on AgenticVBench, including the model–harness configurations, execution limits, and computational resources. Each model–harness configuration is evaluated in three independent runs per task. All experiments are conducted in Modal sandboxes.

Evaluation Metrics

We follow the task-specific evaluation protocols of AgenticVBench [2]. Each task receives a normalized score in [0,1][0, 1], with higher scores indicating better performance. Runs that produce no usable output receive a score of zero. The four task families are evaluated as follows.

Assembly. The verifier checks whether the agent selects the correct source clip for each storyboard slot and adjusts the score for chance performance. Let rr denote the fraction of slots with correctly selected clips and kk the number of candidate clips per slot. The score is

Sassembly=r−1/k1−1/k.(5)S_{\mathrm{assembly}} = \frac{r - 1/k}{1 - 1/k}. \tag*{(5)}

Random selection has an expected score of 0, while selecting the correct clip for every slot yields a score of 1.

Repair. A programmatic verifier measures repair quality by comparing the agent’s output with the corrupted input and a reference output. For a measurement MM where a higher value is better, the normalized score is

s=clip⁡(Mout−MbrokenMgolden−Mbroken,0,1),(6)s = \operatorname{clip}\left(\frac{M_{\mathrm{out}} - M_{\mathrm{broken}}}{M_{\mathrm{golden}} - M_{\mathrm{broken}}}, 0, 1\right), \tag*{(6)}

where MoutM_{\mathrm{out}}, MbrokenM_{\mathrm{broken}}, and MgoldenM_{\mathrm{golden}} are the measurements for the agent’s output, the corrupted input, and the reference output, respectively. The comparison direction is adjusted for measurements where a lower value is better.

For audio and visual defects located within a known time window, the score is

Srepair=0.9 sin+0.1 sout,(7)S_{\mathrm{repair}} = 0.9\,s_{\mathrm{in}} + 0.1\,s_{\mathrm{out}}, \tag*{(7)}

where sins_{\mathrm{in}} measures repair quality inside the window and souts_{\mathrm{out}} measures preservation of the uncorrupted content outside it. For timeline defects, the verifier compares the reported edit ranges with the ground truth and checks that the rendered output is consistent with the reported edits. The score is zero if the consistency checks fail.

Sequencing. The verifier compares the predicted clip order with the reference order using normalized distance (ND), longest increasing subsequence (LIS), and adjacent fidelity (ADJ). These metrics measure overall displacement, global relative order, and preservation of consecutive clip pairs, respectively. The final score is

Sseq=(1−ND)⋅LIS⋅ADJ.(8)S_{\mathrm{seq}} = (1 - \mathrm{ND}) \cdot\mathrm{LIS} \cdot\mathrm{ADJ}. \tag*{(8)}

The multiplicative scores mean alignment across all three dimensions. A perfect ordering receives a score of 1.

Repurpose. Each output is evaluated against a task-specific set of binary rubric items. Format requirements are checked programmatically, while the remaining criteria assess visual presentation, narrative content, and sound. Applicable penalty items deduct points for critical violations of the brief. The resulting task score is normalized to [0,1][0, 1].

Model–Harness Configurations

We evaluate four model–harness configurations, as summarized in Table 5. The command-line interface (CLI) version of each harness is fixed by its corresponding container image. Anthropic and OpenAI models are accessed through the OpenRouter API.

HarnessPackage / sourceVersionModel
Codex CLI@openai/codex0.166gpt-5.6-sol
Claude Code@anthropic-ai/claude-code2.1.220claude-fable-5
OpenCodeopencode-ai1.2.27gpt-5.5
CrayotterGitHub release1.1.0gpt-5.6-sol

Table 5. Harnesses, package or source versions, and corresponding models.

The pinned package versions determine the CLI environment and built-in defaults of each harness.

Run Settings

Table 6 summarizes the experimental settings applied consistently across all model–harness configurations and independent runs.

SettingValue
Maximum agent iterations200
Per-task wall-clock time limit1,800 seconds (30 minutes)
Compute per Modal sandbox4 vCPUs, 8 GB RAM
Model parametersProvider defaults; no overrides applied to temperature, top_p, top_k, seed, or max_output_tokens
Idle timeout per LLM callRespective harness CLI default

Table 6. Benchmark run settings applied consistently across all model–harness configurations.

Token Usage and Estimated Cost

We access model APIs through OpenRouter1 and report token usage and estimated API costs for three model–harness configurations. Table 7 lists the token prices used for cost estimation. Table 8 summarizes token usage and costs by task group. We report Repurpose separately from the other tasks because it uses Gemini 3.1 Pro and Claude Opus 4.7 as evaluators.

ModelInputCached inputOutput
Claude Fable 5$10.00 | $1.00$50.00
GPT-5.6-sol$4.00 | $0.40$20.00
GPT-5.5$5.00 | $0.50$30.00
Claude Opus 4.7$5.00 | $0.50$25.00
Gemini 3.1 Pro$2.00 | $0.20$12.00

Table 7. Token prices used for cost estimation, in US dollars per million tokens.

HarnessTask groupInput (M)Output (M)Cost ($) | Cost/run ($)
Codex + GPT-5.6-solNon-Repurpose364.122.75253.561.32
Codex + GPT-5.6-solRepurpose344.251.92217.472.01
Claude Code + Claude Fable 5Non-Repurpose274.213.64607.323.16
Claude Code + Claude Fable 5Repurpose248.173.57570.875.29
OpenCode + GPT-5.5Non-Repurpose335.866.04600.723.13
OpenCode + GPT-5.5Repurpose114.112.20228.922.12

Table 8. Token usage and estimated cost by harness and task group. Token counts are in millions; costs are in US dollars. Per-run cost is the total cost divided by the number of runs.

Additional Case Studies

As shown in Figure 7, we further analyze representative trajectories from Assembly, Repair, Sequencing, and long-form video Repurpose tasks. These cases illustrate how VIVID supports source inspection, temporal localization, and output review across different editing scenarios.

Figure 7. Additional case studies across four editing tasks. (a) Assembly: selecting four shots from 12 candidates. (b) Repair: locating and restoring two swapped shots. (c) Sequencing: recovering the order of ten shuffled clips. (d) Repurpose: editing a long-form film into a short teaser. The examples illustrate how agents use VIVID’s visual inspection and transcription interfaces to support editing decisions and output review.

Assembly and Sequencing. In Assembly task 1, Claude Fable 5 with Claude Code + VIVID actively inspects candidate frames to distinguish shot scale and camera movement. It selects four shots from 12 candidates, all of which match the reference. In Sequencing task 3, GPT-5.6-sol with Codex + VIVID combines visual observations across clips with speech transcription. It connects a shot of a vacuum cleaner being carried upstairs with a shot of the vacuum cleaner placed beside the same staircase, and all ten positions match the reference order. The agent also reports correcting an approximately 0.08-second AAC padding error and delivers an 86.04-second video. These cases illustrate how VIVID provides visual and linguistic evidence for shot selection and ordering, while supporting checks of the output file.

Repair. In the car shot-swapping task, Codex + VIVID uses discontinuities in dialogue, time-indexed transcription, and local frame inspection to locate the segments to be restored. The agent uses native commands to swap the input frame intervals [145, 205) and [882, 942), then calls VIVID’s inspection tools to review the repaired output. The evaluator reports an IoU of 1.0 for both localized intervals and a mean frame MSE of zero relative to the reference. This case illustrates how VIVID helps the agent associate dialogue cues with visual content and temporal positions, supporting both repair localization and output review before delivery.

Long-form Video Repurposing. In the In the Mood for Love teaser task, Codex + VIVID first generates a sparse 24-frame overview of the 5,640.04-second source film, then requests local word-level transcription for selected segments. It assembles an 82.17-second montage teaser and receives a rubric score of 82/93. This case illustrates VIVID’s layered approach to long-form video: the agent first obtains a sparse visual overview, then acquires finer-grained evidence for candidate content and inspects the edited output.

References

  1. [1]Anthropic. Introducing claude code. https://claude.com/product/claude-code, 2026. 1
  2. [2]Zhongcheng Cao, Yi Zheng, Rui Song, and Xinyu Hu. Agenticbench: Can ai agents complete real-world post-production tasks? arXiv preprint arXiv:2605.27705, 2026. 1, 2, 5, 13arxiv.org/abs/2605.27705
  3. [3]Yuxia Chen, Wenbo Zhu, Yangguang Ji, Zhenxiang Jiang, Teng Zhong, and Yu Zhang. Auto-director: Leveraging multi-agent collaboration for autonomous video editing. arXiv preprint arXiv:2610.28346, 2026. 2arxiv.org/abs/2610.28346
  4. [4]Zihan Ding, Xinyi Wang, Junlong Chen, Per Ola Kristensson, and Junxiao Shen. Prompt-driven agentic video editing system: Autonomous comprehension of long-form, story-driven media. arXiv preprint arXiv:2509.16811, 2025. 2arxiv.org/abs/2509.16811
  5. [5]Yue Fan, Xiaojian Ma, Rujie Wu, Yuntao Du, Jiaq i Li, Zhi Gao, and Qing Li. Videogagent: A memory-augmented multimodal agent for video understanding. In European Conference on Computer Vision, pages 75–92. Springer, 2024. 2arxiv.org/abs/2403.11481
  6. [6]Pengfei Gao, Zhao Tian, Xiangxin Meng, Xinchen Wang, Ruida Hu, Yuanan Xiao, Yizhou Liu, Zhao Zhang, Junjie Chen, Cuiyun Gao, et al. Trae agent: An llm-based agent for software engineering with test-time scaling. arXiv preprint arXiv:2507.23370, 2025. 1arxiv.org/abs/2507.23370
  7. [7]Tanmay Gupta and Aniruddha Kembhavi. Visual programming: Compositional visual reasoning without training. In 2023 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 14953–14962. IEEE, 2023. 2arxiv.org/abs/2211.11559
  8. [8]Qiushi Han, Keya Hu, Linlu Qiu, Cathy Wu, and Kaiming He. Vista: A visual harness for reasoning in an interactive world. arXiv preprint arXiv:2610.02200, 2026. 2arxiv.org/abs/2610.02200
  9. [9]Bernd Huber, Hsiung Valentina Shin, Bryan Russell, Oliver Wang, and Gautham J Mysore. B-script: Transcript-based b-roll video editing with recommendations. In Proceedings of the 2019 CHI Conference on Human Factors in Computing Systems, pages 1–11, 2019. 1, 2DOI
  10. [10]Mackenzie Leake, Abe Davis, Anh Truong, and Maneesh Agrawala. Computational video editing for dialogue-driven scenes. ACM Trans. Graph., 36(4):130–1, 2017. 1, 2DOI
  11. [11]Aiden Yiliu Li, Nels Numan, and Anthony Steed. Visual agentic memory: Enabling online long video understanding via online indexing, hierarchical memory, and agentic retrieval. arXiv preprint arXiv:2605.16481, 2026. 2
  12. [12]Keliang Li, Yansong Li, Hongze Shen, Mengdi Liu, Hong Chang, and Shiguang Shan. Lenswalk: Agentic video understanding by planning how you see in videos. arXiv preprint arXiv:2603.24558, 2026. 2arxiv.org/abs/2603.24558
  13. [13]Shaoteng Liu, Yuechen Zhang, Wenbo Li, Zhe Lin, and Jiaya Jia. Video-p2p: Video editing with cross-attention control. In 2024 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 8599–8608. IEEE, 2024. 2arxiv.org/abs/2303.04761
  14. [14]Chenyu Mu, Wenming Weng, Qinrui Wang, Xingsong Ye, Hao Yu, Jun He, Chong Sun, Chen Li, Jing Lyu, Erkun Yang, et al. Welscut: The whole editing room in one agent from narration to long-form video. arXiv preprint arXiv:2610.38352, 2026. 2arxiv.org/abs/2610.38352
  15. [15]OpenAI. Introducing codex. https://openai.com/zh-Hans-CN/index/introducing-codex/, 2026. Accessed: 2026-04-23. 1
  16. [16]Alejandro Pardo, Jui-Hsien Wang, Bernard Ghanem, Josef Sivic, Bryan Russell, and Fabian Caba Heilbron. Generative timeline for instructed visual assembly. arXiv preprint arXiv:2411.12293, 2024. 2arxiv.org/abs/2411.12293
  17. [17]Marcelo Sandoval-Castañeda, Bryan Russell, Josef Sivic, Gregory Shakhnarovich, and Fabian Caba Heilbron. Edited: A multi-agent system for video non-linear editing. In Proceedings of the Special Interest Group on Computer Graphics and Interactive Techniques Conference Conference Papers, pages 1–11, 2025. 1, 2
  18. [18]Dídac Surís, Sachit Menon, and Carl Vondrick. Vipergpt: Visual inference via python execution for reasoning. In 2023 IEEE/CVF International Conference on Computer Vision (ICCV), pages 11854–11864. IEEE, 2023. 2arxiv.org/abs/2303.08128
  19. [19]Qwen Team. Qwen3.8-omni: Towards native omni-modal agents. arXiv preprint arXiv:2609.25611, 2026. 5arxiv.org/abs/2609.25611
  20. [20]Bekzat Tilekb ay, Saleyne Yang, Michal Adam Lewkowicz, Alex Suryapranata, and Juho Kim. Expressedit: Video editing with natural language and sketching. In Proceedings of the 29th International Conference on Intelligent User Interfaces, pages 515–536, 2024. 2
  21. [21]Bryan Wang, Yuliang Li, Zhaoyang Lv, Haijun Xia, Yan Xu, and Raj Sodhi. Lave: Llm-powered agent assistance and language augmentation for video editing. In Proceedings of the 29th International Conference on Intelligent User Interfaces, pages 699–714, 2024. 1, 2arxiv.org/abs/2402.10294
  22. [22]Xingyao Wang, Yangyi Chen, Lifan Yuan, Yizhe Zhang, Yunzhu Li, Hao Peng, and Heng Ji. Executable code actions elicit better llm agents. arXiv preprint arXiv:2402.01030, 2024. 2arxiv.org/abs/2402.01030
  23. [23]Xingyao Wang, Boxuan Li, Yufan Song, Frank F Xu, Xiangru Tang, Mingchen Zhuge, Jiayi Pan, Yueqi Song, Bowen Li, Jaskirat Singh, et al. Openhands: An open platform for ai software developers as generalist agents. arXiv preprint arXiv:2407.16741, 2024. 1arxiv.org/abs/2407.16741
  24. [24]Xiaohan Wang, Yuhui Zhang, Orr Zohar, and Serena Yeung-Levy. Videoagent: Long-form video understanding with large language model as agent. In European Conference on Computer Vision, pages 58–76. Springer, 2024. 2
  25. [25]Xingyao Wang, Boxuan Li, Yufan Song, Frank F Xu, Xiangru Tang, Mingchen Zhuge, Jiayi Pan, Yueqi Song, Bowen Li, Jaskirat Singh, et al. Openhands: An open platform for ai software developers as generalist agents. In International Conference on Learning Representations, pages 65882–65919, 2025. 2arxiv.org/abs/2407.16741
  26. [26]Yukun Wang, Longguang Wang, Zhiyuan Ma, Qibin Hu, Kai Xu, and Yulan Guo. Videodirector: Precise video editing via text-to-video models. In 2025 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 2589–2598. IEEE, 2025. 2arxiv.org/abs/2411.17592
  27. [27]Ziyang Wang, Shoubin Yu, Elias Stengel-Eskin, Jaehong Yoon, Feng Cheng, Gedas Bertasius, and Mohit Bansal. Videotree: Adaptive tree-based video representation for llm reasoning on long videos. In 2025 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 3272–3282. IEEE, 2025. 2arxiv.org/abs/2405.19209
  28. [28]Lecheng Yan, Jianze Lin, Yichong Zhang, Ben Pan, Wenxi Li, Chenyang Lyu, Linting Zhou, and Cathal Gurrin. Cray-otter: Learning long-horizon video editing agents via group-relative preference backpropagation. arXiv preprint arXiv:2608.02694, 2026. 2arxiv.org/abs/2608.02694
  29. [29]Lecheng Yan, Yichong Zhang, Xiantao Xu, Jianze Lin, Ben Pan, Xiaoyu Zheng, Jiawei Qian, Anqi Wu, Jiahui Geng, Ruizhe Li, et al. Crayoter: Traceable multi-agent workflows for long-form video editing. arXiv preprint arXiv:2606.07636, 2026. 1, 2, 4, 5arxiv.org/abs/2606.07636
  30. [30]John Yang, Carlos Jimenez, Alexander Wettig, Kilian Lieret, Shunyu Yao, Karthik Narasimhan, and Ofir Press. Swe-agent: Agent-computer interfaces enable automated software engineering. Advances in Neural Information Processing Systems, 37:50528–50652, 2024. 2arxiv.org/abs/2405.15793
  31. [31]Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. React: Synergizing reasoning and acting in language models. arXiv preprint arXiv:2210.03629, 2022. 2arxiv.org/abs/2210.03629
  32. [32]Zhixin Zeng and Jiahao Zhong. Cassette-editor: A video editing agent that edits the way you do. arXiv preprint arXiv:2610.37690, 2026. 2arxiv.org/abs/2610.37690
  33. [33]Zhaoxi Zhang, Yitong Duan, Yanzhi Zhang, Yiming Xu, Zhixiang Wang, Kun Liang, Yang Li, Jiahui Liang, Deguo Xia, Jizhou Huang, et al. One tool is enough: Reinforcement learning for repository-level llm agents. arXiv preprint arXiv:2512.20957, 2025. 1arxiv.org/abs/2512.20957
  34. [34]Hengji Zhou, Lingxuan Huang, Jian Wang, Bing Zhou, Si Wu, Lianghao Xia, and Chao Huang. Videogagent: All-in-one framework for video understanding and editing. arXiv preprint arXiv:2606.23327, 2026. 2arxiv.org/abs/2606.23327

Paper details

vlnc:W_epy8umxq
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents