File size: 13,639 Bytes
ce07a15
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
60db338
 
 
ce07a15
 
 
60db338
 
 
ce07a15
60db338
ce07a15
 
 
60db338
 
 
ce07a15
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
60db338
ce07a15
 
60db338
ce07a15
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
---
license: other
language:
  - en
task_categories:
  - video-to-video
pretty_name: AgentEdit-Bench
tags:
  - video-editing
  - benchmark
  - agent
  - underspecification
size_categories:
  - n<1K
configs:
  - config_name: default
    data_files:
      - split: test
        path: prompts.jsonl
---

<div align="center">

# AgentEdit-Bench

### Agent-enhanced video editing under textual and visual underspecification

[![arXiv](https://img.shields.io/badge/arXiv-2605.18748-b31b1b.svg)](https://arxiv.org/abs/2605.18748)
[![Project Page](https://img.shields.io/badge/Project-Page-1f6feb.svg)](https://yeates.github.io/Aurora-Page)
[![Code](https://img.shields.io/badge/GitHub-Aurora-181717.svg?logo=github)](https://github.com/yeates/Aurora)
[![HF Models](https://img.shields.io/badge/🤗%20Models-Weights-FFD21E.svg)](https://huggingface.co/yeates/aurora-weights)
[![HF Dataset](https://img.shields.io/badge/🤗%20Dataset-Training-FFD21E.svg)](https://huggingface.co/datasets/yeates/aurora-training-data)

</div>

AgentEdit-Bench is the video-editing benchmark introduced with
**Aurora: Unified Video Editing with a Tool-Using Agent** (NeurIPS 2026). Its
150 cases pair a source clip with a request that leaves out something a video
editor needs: a reference image for a named entity, a mask for the object to
remove, or a direct statement of the edit. Edited videos are scored by a VLM
judge.

## Aurora

Aurora is an agentic video-editing framework. Given a source video and a
natural-language request, a tool-using vision-language agent first resolves
ambiguity: it rewrites the request into an editor-facing instruction, decides
the edit type, optionally retrieves a reference image from the web, and
optionally grounds a target object with a mask. A unified video diffusion
editor then performs the actual edit.

The editor uses a WAN2.2-TI2V-5B diffusion transformer, a WAN2.2 VAE, and a
frozen Qwen3.5-4B multimodal LLM; the agent is a Qwen3-VL-8B-Instruct planner
with an Aurora LoRA adapter. One editor checkpoint supports source-conditioned
editing (s2v), video-to-video editing (v2v), and reference-conditioned editing
(sv2v).

**News**

- **2026-09**: Aurora is accepted to NeurIPS 2026.
- **2026-06**: Code, model weights, and training data are released.
- **2026-05**: The paper is released on arXiv.

## The benchmark

Real editing requests rarely arrive in a model-ready form. Each case is built
around a request that is underspecified along one of two axes:

- **Visual underspecification.** The request names a specific real-world
  entity (a brand, product, character, landmark, or artwork) without a
  reference image, or names an object to remove without a mask.
- **Textual underspecification.** The edit is described only indirectly, so the
  concrete editing goal has to be inferred.

| Edit type (`edit_type`) | Cases | What the request leaves out | Example request |
|---|---:|---|---|
| IP replacement (`ip_object_replace`) | 56 | Appearance of the named entity | *Replace the white armchair in the background with a classic Eames Lounge Chair.* |
| IP addition (`ip_object_add`) | 40 | Appearance of the named entity | *Add a Goodyear blimp flying in the empty blue sky to the left of the kite.* |
| IP background change (`ip_background_change`) | 12 | Appearance of the named place | *Change the background view through the window to a realistic New York City skyline at sunset while keeping the interior and people unchanged.* |
| Reasoning (`reasoning`) | 17 | A direct statement of the edit | *Turn the lake into a perfect mirror for the passing clouds above.* |
| Removal (`removal`) | 25 | Location of the target and of its physical effects | *Remove the white tennis racket resting vertically on the court. You must also completely erase the intricate shadow cast by its frame and strings onto the ground, replacing it with the natural, continuous texture of the clay surface.* |

"IP" stands for a named real-world entity such as a brand, product, character,
or artwork.

- Reasoning requests use four linguistic styles (`reasoning_style`):
  referential (5), property (5), counterfactual (5), and elliptical (2).
- In 18 of the 25 removal cases the target carries physical effects that must
  disappear with it (`physical_effects`, multi-label): shadow cast (14), mirror
  reflection (4), water reflection (4), complex occlusion (4), water ripple (3),
  light cast (2), and footprints (1).

The same clips support three evaluation protocols:

1. **Full framework.** The Aurora agent plans each edit and the Aurora editor
   renders it.
2. **Agent transfer.** The Aurora agent's plan drives another video editing
   model.
3. **Instruction only.** Any video editing model edits from the raw request
   alone.

## Dataset structure

```text
AgentEdit-Bench/
├── prompts.jsonl     # 150 cases: what a system under test receives
├── cases.json        # 150 cases: the same inputs plus judge annotations
└── source_videos/    # 140 source clips (MP4)
```

The clips are 102 landscape and 38 portrait videos, from 480p to 4K, and 1.8 to
30.5 s long (median 5.9 s). Nine clips are shared by two or three cases with
different requests. All paths are relative to the dataset root.

`prompts.jsonl` holds one case per line:

```json
{"case_id": "ip_object_replace_001", "edit_type": "ip_object_replace", "src_video": "source_videos/clip_001.mp4", "prompt": "Replace the vase with white tulips on the counter with a LEGO Botanical Collection Orchid."}
```

`cases.json` is a list with the same fields plus the annotations the judge
uses:

```json
{
  "case_id": "ip_object_replace_001",
  "edit_type": "ip_object_replace",
  "src_video": "source_videos/clip_001.mp4",
  "prompt": "Replace the vase with white tulips on the counter with a LEGO Botanical Collection Orchid.",
  "target_entity": "LEGO Botanical Collection Orchid",
  "edit_region": "the vase with white tulips on the left side of the counter",
  "web_query": "LEGO Botanical Collection Orchid product photo"
}
```

| Field | Description |
|---|---|
| `case_id` | Unique id, `<edit_type>_<NNN>`. |
| `edit_type` | `ip_object_replace`, `ip_object_add`, `ip_background_change`, `reasoning`, or `removal`. |
| `src_video` | Source clip. |
| `prompt` | The user request, exactly as the system under test receives it. |
| `target_entity` | The named entity an IP edit must show. Empty for reasoning and removal. |
| `edit_region` | The region the edit should stay within. Empty when not annotated. |
| `web_query` | A canonical image-search query for `target_entity`. Empty for reasoning and removal. |
| `reasoning_style` | Reasoning cases only: `referential`, `property`, `counterfactual`, or `elliptical`. |
| `physical_effects` | Removal cases only: effects tied to the target, such as `shadow_cast` or `water_reflection`. Empty when none are annotated. |

> [!IMPORTANT]
> A system under test should receive only `prompt` and the source clip.
> `target_entity`, `edit_region`, and `web_query` are judge annotations; giving
> them to an editor or agent removes the underspecification the benchmark
> measures.

## Usage

### Download

```bash
hf download yeates/AgentEdit-Bench --repo-type dataset --local-dir AgentEdit-Bench
```

```python
from huggingface_hub import snapshot_download

bench_dir = snapshot_download("yeates/AgentEdit-Bench", repo_type="dataset")
```

### Run Aurora

The inference and scoring scripts are part of the
[Aurora code](https://github.com/yeates/Aurora); run the commands below from its
repository root. First, let the Aurora agent plan every case. Web image search
uses the Serper API.

```bash
export BENCH=/abs/path/to/AgentEdit-Bench

# Convert the benchmark into the agent's case format.
python - <<'EOF'
import json, os

bench = os.environ["BENCH"]
with open(os.path.join(bench, "prompts.jsonl")) as src, open("agentedit_cases.jsonl", "w") as dst:
    for line in src:
        case = json.loads(line)
        dst.write(json.dumps({
            "bench_id": case["case_id"],
            "edit_type": case["edit_type"],
            "prompt": case["prompt"],
            "video_path": os.path.join(bench, case["src_video"]),
        }) + "\n")
EOF

export SERPER_KEY_ID=<your-serper-key>
python -m aurora.agent \
  --custom_cases_jsonl agentedit_cases.jsonl \
  --custom_only \
  --mask_backend grounded_sam \
  --out_dir "$PWD/agent_out" \
  --serper_api_key "$SERPER_KEY_ID"
```

Then render the plans with the Aurora editor, using the settings from the
paper:

```bash
python evaluation/agentedit_bench_infer.py \
  --bench_dir "$BENCH" \
  --agent_records_jsonl "$PWD/agent_out/agent_pipeline_records.jsonl" \
  --use_mask_overlay \
  --num_gpus 8 \
  --max_pixels 921600 \
  --num_frames 81 \
  --cfg_scale 2.0 \
  --image_cfg_scale 1.25 \
  --out_dir "$PWD/results/aurora"
```

Keep `--out_dir` absolute for the agent: the editor resolves relative asset
paths against `--bench_dir`. For the instruction-only protocol, drop
`--agent_records_jsonl` and `--use_mask_overlay`. For agent transfer, give your
editor each record's `final_payload` (`refined_text_instruction`, the
`search_image` path, and the `object_mask` path, either of which may be
`false`) in place of the raw request.

### Score

The scorer reads one edited video per case from
`<results_dir>/<case_id>/generate.mp4`. To score another editor, save its
outputs the same way. If the editor resizes or trims its input, also save the
matching input as `<results_dir>/<case_id>/source.mp4` so that the BEFORE and
AFTER frames line up.

```bash
export GEMINI_API_KEY=<your-gemini-key>
python evaluation/agentedit_bench_score.py \
  --bench_dir "$BENCH" \
  --results_dir "$PWD/results/aurora" \
  --api openai \
  --base_url https://generativelanguage.googleapis.com/v1beta/openai/ \
  --api_key "$GEMINI_API_KEY" \
  --model gemini-2.5-pro
```

This runs the judge as in the paper: Gemini 2.5 Pro at temperature 0, called
through its OpenAI-compatible endpoint, without web search. Scores are written
to `<results_dir>/scores.json`. The values
`summary.by_edit_type.<edit_type>.avg_pct_on_1` and `summary.overall_pct_on_1`,
multiplied by 100, are the numbers reported in the table below.

## Evaluation protocol

Gemini 2.5 Pro at temperature 0, without web search, compares three
BEFORE/AFTER frame pairs per case, taken at frames 0, *k*, and 2*k* of the
edited clip with *k* = ⌊N/3⌋, and scores each axis from 0 to 3.

| # | Axis | What it measures | Applies to |
|---|---|---|---|
| 1 | Instruction Following | Whether the requested edit happened in the named region with the named target | All types |
| 2 | Edit Region Localization | Whether the change stays inside the specified region | All types |
| 3 | Source Preservation | Whether unedited regions, motion, geometry, and lighting are preserved | All types |
| 4 | Visual Quality | Realism, lighting and shadow match, scale and perspective, absence of paste-on artifacts | All types |
| 5 | Temporal Consistency | Whether the edited content would stay stable across the clip | All types |
| 6 | IP Presence | Whether the named entity is visible and recognizable in roughly the right region | IP edits |
| 7 | IP Identity Match | Whether the visible entity matches the specific real-world identity (brand colors, logo, signature shape) | IP edits |

IP edits are scored on all seven axes (maximum 21); reasoning and removal cases
on axes 1 to 5 (maximum 15). A removal output that replaces the target with a
new object scores at most 1 on Instruction Following. Axis scores are averaged
over the three frames, each case is normalized by its maximum, and per-type and
overall scores are means over cases, reported as percentages.

## Results

Table 2 of the paper. ✓ means the editor is paired with the Aurora VLM agent;
– means it edits from the raw request.

| Method | Aurora agent | IP Replace | IP Add | IP Background | Reasoning | Removal | Overall |
|---|:---:|---:|---:|---:|---:|---:|---:|
| UniVideo | – | 67.1 | 63.4 | 65.6 | 77.3 | 66.5 | 67.0 |
| UniVideo | ✓ | 80.3 | 81.3 | 66.8 | 74.6 | 68.1 | 76.8 |
| Kiwi-Edit | – | 66.7 | 65.1 | 86.6 | 79.5 | 69.0 | 69.7 |
| Kiwi-Edit | ✓ | 71.6 | 73.1 | 78.3 | 84.3 | 57.8 | 71.7 |
| Aurora | – | 73.0 | 68.0 | 71.2 | 86.4 | 83.0 | 74.7 |
| **Aurora** | ✓ | **89.6** | **85.3** | **90.1** | **88.1** | **86.8** | **87.9** |

## Source attribution and licenses

AgentEdit-Bench is intended for research evaluation. The source clips are
third-party footage, and each keeps its original license; consult the source
before redistribution or commercial use.

- **Pexels.** The 123 clips used by the IP and removal cases come from the
  [Pexels](https://www.pexels.com) stock library and are covered by the
  [Pexels License](https://www.pexels.com/license/).
- **Public video-editing datasets.** The 17 reasoning clips are source videos
  from [Ditto-1M](https://huggingface.co/datasets/QingyanBai/Ditto-1M) (9),
  [OpenVE-3M](https://huggingface.co/datasets/Lewandofski/OpenVE-3M) (6),
  [ReCo-Data](https://huggingface.co/datasets/HiDream-ai/ReCo-Data) (1), and
  [EffectErase](https://huggingface.co/datasets/FudanCVL/EffectErase) (1).

The editing requests and all annotations in `prompts.jsonl` and `cases.json`
were created and curated by the Aurora authors.

## Citation

```bibtex
@inproceedings{yu2026aurora,
  title={Aurora: Unified Video Editing with a Tool-Using Agent},
  author={Yu, Yongsheng and Zeng, Ziyun and Xiao, Zhiyuan and Zhou, Zhenghong and Hua, Hang and Xiong, Wei and Luo, Jiebo},
  booktitle={Advances in Neural Information Processing Systems (NeurIPS)},
  year={2026}
}
```