EditHero: Breaking Down the First Benchmark for Long-Horizon, Part-Level 3D Editing

3D Editing in the Real World: It's Never Just One Shot

Most existing 3D editing methods are evaluated on single, isolated edits — but in real asset production pipelines, a 3D model is typically refined through a long series of successive revisions. Each modification must precisely implement the requested change while leaving everything else untouched. This "long-horizon, iterative" workflow has been a glaring blind spot in previous evaluation frameworks.

EditHero was designed to address exactly this gap. The research team claims it is, to their knowledge, the first benchmark specifically targeting long-horizon, part-level 3D editing. It comes equipped with natural language instructions and target images covering both geometry and texture, making evaluation far more aligned with real production demands.

A Deterministic Assembly Engine with Human Review

One of EditHero's core design choices is the introduction of a deterministic assembly engine. After each edit, the system produces a precise, reproducible target result — rather than relying on the inherent randomness of generative models. This determinism provides a reliable ground truth for evaluation, making it possible to objectively measure whether each editing step was executed correctly.

In addition to the automated engine, every editing sequence is manually reviewed one by one. This dual-layer approach — machine generation plus human oversight — ensures the benchmark's quality and credibility, giving future research a clean, controlled data foundation to build on.

The term "deterministic" here is defined in contrast to the stochasticity of mainstream generative methods like diffusion models. Diffusion models introduce random noise at each inference step, meaning the same instruction can yield multiple different outputs, making objective evaluation difficult — there's no clear way to determine which output is the "correct" one. The deterministic assembly engine, by contrast, uses rule-driven or parametric composition: given the same part library and editing instructions, it produces an identical target model every time, providing a stable and reproducible ground truth. This design philosophy echoes the unit testing principles of traditional software engineering — repeatability and verifiability are prerequisites for a trustworthy evaluation framework.

Two Opposing 3D Editing Paradigms Go Head-to-Head

EditHero's most valuable contribution is the systematic comparison it enables between two fundamentally different approaches to 3D editing.

Non-Agentic Methods: Top-Down Regeneration

The first category is non-agentic methods, which work in a top-down fashion. Starting from a learned 3D representation, they regenerate the object holistically and attempt to infer which parts should be preserved. The fundamental problem here is that the model must "guess" which regions should remain unchanged beyond the user's explicit request — and often gets this wrong.

Experiments show that non-agentic methods frequently miss the changes users actually requested while disturbing regions that should have stayed untouched. In other words, they change what shouldn't be changed and miss what should be — a critical failure mode in production scenarios requiring precise, iterative refinement.

Typical representatives of this category include editing systems built on NeRF (Neural Radiance Fields) or 3D Gaussian Splatting. These systems generally encode the 3D object into some form of implicit or explicit neural representation, then guide the reconstruction process using text or image conditions. Because the generation process is holistic, the model lacks explicit awareness of "what needs to change vs. what must stay the same," relying instead on statistical patterns learned from training data to make implicit inferences. This explains why they struggle with precise part-level editing — a neural network's "understanding" is not equivalent to explicit manipulation of structural semantics.

LLM/VLM Agents: Bottom-Up Code-Based Editing

The second category is agent-based methods powered by large language models (LLMs) and vision-language models (VLMs), which take a bottom-up approach. They perform edits through code — inspecting mesh structures and rewriting only the specific parts that the instruction calls for.

The advantages are clear: most LLMs demonstrate stronger instruction-following fidelity, and all tested LLMs perform better at preserving unedited regions. This is precisely the capability that matters most in iterative editing — making targeted local changes without breaking the overall structure.

Agent-based methods typically operate on procedural 3D representations such as parametric meshes, CSG (Constructive Solid Geometry), or Python-scripted modeling libraries. The LLM reads code or metadata describing the model's structure, translates natural language instructions into concrete editing operations (e.g., "change the chair leg height parameter from 0.4 to 0.6"), and rebuilds the target model by executing the modified code. VLMs can additionally process visual feedback to verify whether the editing result matches the intended appearance. This "code as representation" paradigm naturally supports precise addressing of individual parts, and makes editing operations auditable and reversible — both valuable properties in professional content production workflows.

The Precision–Efficiency Trade-off

While agent-based methods hold the advantage in accuracy, they come at a cost. The research notes that LLM-based methods take several minutes per edit. For creative workflows requiring frequent iteration, this latency is a non-trivial bottleneck.

This finding exposes the central tension in today's 3D editing landscape: non-agentic methods are fast but unreliable; agent-based methods are reliable but slow. Finding a balance between the two — or combining the strengths of both paradigms — will be an important direction for future research.

Open Resources to Drive Reliable Iterative Editing Research

The research team has committed to publicly releasing both the assembly engine and the editing sequences, in support of reproducible, reliable iterative 3D editing research. This open approach is significant for the community — it provides not only a standardized evaluation tool, but also a foundation for comparing different methods and reproducing experimental results.

As demand for 3D content continues to grow across gaming, film, industrial design, and the metaverse, tools that enable precise and reliable iterative editing will become increasingly essential. The problems EditHero surfaces and the evaluation framework it establishes may well prove to be a foundational stepping stone in driving this field toward maturity.