The one-paragraph version
This paper introduces 3DHarnessBench, a test that asks vision-language models to act like 3D modelers: look at a target object and write a Blender Python program that recreates it. The twist is that the same rebuilding job is given under four different levels of access, from just one fixed photo, to four fixed photos, to freely moving the camera around the target, to fully measuring the target with Blender tools. The authors test seven frontier models in their normal agent setups, all connected to Blender through what is called Blender MCP, which basically lets the model call Blender functions as tools. They find a clear pattern: more access helps on average, but very unevenly. Everyone improves from one to four views and again with full measuring access, while free camera control sharply separates strong from weak agents — some gain up to about 16% in 3D similarity, others get worse by up to about 17%. Even the best agent still falls short of perfect reconstruction, showing that actively gathering and using 3D evidence is an emerging but unreliable skill.
The problem they're solving, and why it matters
Frontier vision-language models, meaning AI systems that take in both images and text, are increasingly used as agents, meaning they do not just answer a question in one shot but take a sequence of actions, call tools, look at results, and revise. The question here is: how much real 3D understanding do these agents have when they have to make something, not just talk about it?
Earlier tests mostly checked what the authors call perceptual understanding. For example, can a model answer “is the cup to the left of the plate?” or “how many legs does this chair have in this view?” That is useful, but it does not tell you if the model could actually build the 3D shape.
A newer line of work, sometimes called executable inverse graphics, flips the test. Inverse graphics means going backward from images to the underlying 3D structure that produced them. Executable means the answer must be a program you can run. In this case: write Blender code, run it, and see if the resulting object matches the target in shape, structure, and looks.
The gap the paper points to is that existing code-to-3D tests give the model a fixed input, like one image or four preset images. That tangles together different failures. If the model builds a bad bird, was it because it cannot infer depth from one photo, because it cannot combine four photos, or simply because it never saw the back of the bird and no one let it look? It also never tests the core agent skill: going and finding the evidence you need on your own.
The key idea, in plain words
Keep the job fixed — rebuild this object as runnable Blender code — but systematically change how much the agent is allowed to snoop on the target.
Think of it like testing a human sculptor under four conditions. Level 1: you get one photo and never see the object again. Level 2: you get four photos from fixed angles. Level 3: you can walk around the museum case, zoom in, and look from any angle while you sculpt. Level 4: you also get calipers and a tape measure and can ask “how wide is the bounding box?” or “where are the parts?”
If performance jumps from Level 1 to Level 2, that tells you fixed extra views help. If it jumps or collapses from Level 2 to Level 3, that tells you whether the agent can handle freedom — choosing good viewpoints and not getting confused by its own tool use. If Level 4 helps most, that tells you explicit numbers ground the model better than pictures alone. By comparing the same 100 objects across all four levels, the benchmark tries to separate seeing, from actively looking, from actively measuring and fixing mistakes.
How it actually works, step by step
The target set is 100 diverse objects sampled from an earlier dataset called 3DCodeBench, one per category — examples discussed include a bird, crustacean, auger shell, and flower plant. For each target the agent never sees the original authoring program, only images or, in interactive settings, the loaded 3D asset in Blender.
The four harnesses, meaning the controlled interaction setups, are:
Single-view: one fixed target image plus the ability to run its own Blender code and render what it built. This tests inferring hidden 3D shape from one projection, where much is occluded, meaning hidden behind what is visible.
Multi-view: four fixed target views spaced 90 degrees in yaw, meaning turning around the object like a turntable, plus the same rebuild-and-render tools. This tests combining fixed evidence. In this paper both fixed settings also get three rounds of look-at-your-render-and-revise.
Active Visual: the agent can control the camera on a separate, restricted view of the target. Restricted here means an allowlist check only permits camera and viewport moves, not reading the target geometry directly. It can zoom, orbit, inspect details, then edit its reconstruction in its own workspace. This mimics a human flipping the reference back and forth while modeling.
Full 3D Interaction: everything above plus full Blender measuring tools in the same scene — bounding boxes, dimensions, distances, part centers and counts. The prompt explicitly forbids cheating by copying the target mesh or materials directly; the result must be procedurally generated, meaning built from code operations like primitives, extrusions, and modifiers rather than pasted.
Each of seven models — Fable 5, Opus 5, GPT-5.6 Sol, Kimi K3, Qwen 3.8 Max, Gemini 3.1 Pro, and MiniMax M3 — runs in its official agent command-line setup with its native tool handling. Scoring covers appearance, meaning rendered-image similarity using learned image features called SigLIP2, DINOv2 and DINOv3; geometry, meaning shape similarity using Chamfer distance, which in plain words is the average gap between sampled surface points after aligning centers and scales, and Uni3D, which is similarity in a learned 3D feature space; and topology, meaning structural correctness using Betti numbers, which roughly count separate pieces, tunnels or loops, and enclosed voids. They also track cost in tool calls, tokens, and time.
What they showed — results, honestly, with limitations
The broad hierarchy holds, but agent differences dominate.
Moving from one to four fixed views helped all seven agents on Chamfer distance and Uni3D similarity. More fixed evidence reduces ambiguity.
Active Visual was the sharpest discriminator. From Multi-view to Active Visual, Uni3D changed by +16.4% for Opus 5, +14.9% for Kimi K3, +10.5% for GPT-5.6 Sol, +8.9% for Fable 5 and +5.3% for Qwen 3.8 Max, but −8.2% for Gemini 3.1 Pro and −16.5% for MiniMax M3. The gap between worst and best grew to 44.7% of the top score, versus about 25–33% under fixed views. Chamfer ratios widened similarly from roughly 2 times to 8.5 times. In plain terms: freedom helped good explorers and hurt poor ones.
Full 3D Interaction gave every agent its best geometry. Opus 5 was best overall with, for example, Uni3D 0.927 and Chamfer 0.002, followed by a competitive group of Fable 5, GPT-5.6 Sol, Kimi K3 and Qwen 3.8 Max, with Gemini 3.1 Pro and MiniMax M3 behind. Qualitative examples show interactive access recovering body proportions, appendages, helical repeats, and multi-part layouts that fixed views missed.
Follow-up ablations on a small 10-object subset suggest why. Giving camera pose, meaning where each photo was taken from, helped more than showing a metric grid floor. Viewport normalization, meaning resetting shading and framing before screenshots, largely rescued MiniMax M3, while replaying Fable 5’s inspection photos rescued Gemini 3.1 Pro — pointing to observation quality and inspection strategy, not just 3D reasoning, as failure sources. Log counts show Gemini inspected very little, about 5 target views on average, while MiniMax inspected a lot but repetitively. Adding explicit global or part measurements improved geometry and topology. First-draft quality and later self-correction were distinct skills: Opus 5 started strongest, while MiniMax and Qwen made the largest fixes from weak starts.
Limitations to keep in mind: only 100 single objects, not full scenes with placement or contact; ablations are only 10 instances so percentages are noisy; failed programs are penalized with zero similarity and an inflated Chamfer value, which is reasonable but affects averages; appearance matching aligns views by best assignment, which forgives orientation errors; efficiency varies wildly and Full 3D needing fewer calls partly reflects sharing one Blender process instead of two; and the extra perceptual judge is Gemini 3.1 Pro judging its own competitors, though the authors note it rated itself second-lowest, suggesting no obvious self-favoritism. It is also unclear from the text alone how the “performance ceiling” in Figure 1 is computed.
Why this might matter to me
For spatial reasoning in LLMs and VLMs, this moves beyond asking questions about space to demanding buildable hypotheses. The four-level design is useful as a diagnostic: if a model fails at Single-view but succeeds with pose-annotated Multi-view, the bottleneck may be view integration rather than shape priors. The finding that camera pose helps more than a visual grid is directly relevant to how you prompt or scaffold spatial agents.
For world models, the Active Visual result is the caution. A world model that cannot decide where to look next, keep observations well-framed, and compare target versus prediction from matched viewpoints will waste its interaction budget. The paper’s trajectory examples — Opus 5 slicing with a clipping plane to see inside versus repetitive zooming — are concrete patterns for what good active perception looks like.
For text-to-CAD and parametric geometry, the Full 3D results support a two-stage intuition the authors use: geometry first, then materials, with measurements as anchors. Global bounding boxes plus anonymous part centers, sizes, and repetition counts gave the clearest gains in shape and topology. That suggests CAD agents should explicitly query dimensions and part statistics before committing to procedural operations like arrays, mirrors, sweeps, and booleans, rather than trying to eyeball proportions.
For 3D generation and scene representation, the representation choice matters. Because output must be Blender code, every decision about primitives, transforms, and part relationships is inspectable and editable. The included auger example — fitting a logarithmic coil model with measured axis, growth, and color bands — shows how code exposes interpretable structure that mesh-only generators hide. The downside, visible in thin, repeated, and multi-part failures, is that code is brittle: without strong structural reasoning, full access still does not guarantee fine detail. Future work the authors propose on multi-object scenes and training smaller models on these interaction traces follows naturally.
Terms worth knowing
Vision-language model (VLM): an AI model that takes images plus text as input and produces text or actions. Here the text it produces is Blender code.
Agent and harness: an agent is a VLM wrapped in a loop that can call tools and revise. A harness is the controlled setup that decides what tools and target access the agent gets.
Blender MCP: Model Context Protocol connection to Blender. In practice, a way for the agent to run Blender Python, take viewport screenshots, move cameras, render, and query scene info by calling named functions.
Executable inverse graphics / 3D-to-code: the task of inferring the 3D cause behind images and expressing it as a runnable program. Run the program and you should get the shape back.
Single-view, Multi-view, Active Visual, Full 3D Interaction: the four access levels from one fixed photo, to four fixed photos, to self-chosen camera views, to self-chosen views plus numeric 3D measurements.
Chamfer distance: a geometry error score based on sampled surface points. For each point on one shape find the nearest point on the other and average those gaps both ways. Lower is better. Here shapes are centered, scaled, and tried in 24 axis-aligned rotations to forgive orientation differences.
Uni3D: a learned 3D similarity score. Instead of raw point gaps, both shapes are mapped to feature vectors and compared by cosine similarity, meaning angle between vectors. Higher is better. An image-to-3D variant compares a target photo to the rebuilt shape.
SigLIP2 / DINOv2 / DINOv3: learned image similarity scores. Render target and rebuild from the same-style viewpoints and compare image features. Higher means more similar looking.
Betti numbers: topology counts that describe structure at a coarse level — roughly number of separate components, loops or tunnels, and enclosed cavities. The paper reports normalized error in these counts, where lower is better.