LEGO-Anything: Coding Agents for 3D Scene Reconstruction

Abstract: A 3D scene reconstructed from a single image is most useful when represented not as a rendering or a fixed 3D output, but as an explicit scene program whose execution yields a scene that can be inspected, edited, and queried. We present LEGO-Anything, an Image-to-Code framework in which a coding agent iteratively writes and executes Blender code, inspects scenes and renderings, and revises the program. To evaluate end-to-end scene recovery, we introduce LEGO-Bench, a simulator-grounded benchmark with 208 images from 104 diverse indoor and outdoor scenes. LEGO-Bench separately scores artifact validity, visible-surface geometry, and rendered appearance. Its simulator-grounded design enables extensibility and precise automatic evaluation. Among evaluated agents, GPT-6-astra achieves the strongest overall results, with 53.4% indoor and 39.6% outdoor scores, yet substantial gaps remain between delivering valid scene artifacts and faithfully recovering scene geometry and appearance. Analysis of agent construction trajectories reveals three recurring issues: weak scene initialization, regressive edits during iteration, and unreliable self-evaluation. These findings motivate LEGO-Plugin, a training-free harness plugin for more controlled iterative scene construction, which improves all six evaluated models, with relative gains of up to 62.7% in overall score. Finally, we test whether reconstructed scenes can represent natural images and support vision tasks. In LEGO-World, we derive object detections, instance masks, and relative depth as deterministic queries on scenes reconstructed by GPT-6-astra. These readouts show non-trivial performance across all three tasks but fall well short of specialized vision models, suggesting that program-constructed scenes from current coding agents are a promising but not yet sufficiently precise representation of natural images.

• The paper proposes an innovative approach to 3D scene reconstruction by encoding reconstructions as executable Blender programs, facilitating editable, inspectable, and queryable scenes .
• LEGO-Anything demonstrates that while coding agents excel at producing valid Blender scenes, geometric and visual fidelity remains a significant challenge—the optimal executed computation had near-saturated artifact validity, but geometrics, fidelity and visual fidelity were much lower than traditional mesh/reconstruction benchmarks.
• The LEGO-Bench evaluation framework provides a unique and important methodology for assessing both scene fidelity and representation quality in 3D scene reconstruction, and potentially facilitates exploring new strategies for self evalution and iteratively refining visual comparisons that improve understanding genericity and scene usability in reuscable scene representations.

The paper studies single-image 3D reconstruction as an executable programming problem rather than as direct prediction of a mesh, point cloud, or fixed scene representation. Its central claim is that a reconstruction is more useful when it is encoded as a Blender program whose execution produces an editable, inspectable, and queryable scene. The proposed system, LEGO-Anything, uses a general-purpose coding agent to iteratively interpret an RGB image, write and execute Blender code, inspect rendered outputs, and revise the scene program. The work introduces two evaluation resources around this formulation: LEGO-Bench, for end-to-end reconstruction, and LEGO-World, for testing whether reconstructed scenes support downstream visual tasks (2609.36380).

Executable scene reconstruction as Image-to-Code

LEGO-Anything defines reconstruction as a policy-mediated interaction between an image, a coding environment, and a scene executor. Given an image $I$, an agent produces a program $P$ through repeated code-editing and execution steps; executing $P$ yields a scene $S$. The scene program is therefore both the output representation and the operational interface through which the agent performs reconstruction.

This formulation changes the optimization target in several ways. The agent is not required to infer a complete scene in one forward pass. It can establish a coarse scene, render it, compare the result with the reference, and apply subsequent edits. Objects, camera parameters, geometry, materials, lighting, and spatial layout remain explicit in the Blender state. The resulting artifact can also be exported and interrogated after construction.

Figure 1: An agent iteratively converts a single RGB image into an executable Blender scene program through planning, code editing, rendering, and inspection.

The workflow is implemented with general-purpose coding agents operating through Blender MCP in a shared execution environment. The agent receives the reference image and public task metadata but not the benchmark’s private geometry, masks, depth, or evaluator scores. Intermediate programs and scenes form a construction trajectory, allowing the paper to evaluate not only final fidelity but also initialization quality, edit behavior, and the relationship between intermediate and final states.

Figure 2: Agentic scene construction organized around the workspace, action space, Blender code state, and iterative validation workflow.

The choice of executable programs is consequential. A valid Blender file can be opened, rendered, edited, and exported even when its visual fidelity is poor. Consequently, the paper explicitly separates artifact deliverability from reconstruction quality rather than treating successful program execution as evidence of faithful reconstruction.

LEGO-Bench: simulator-grounded end-to-end evaluation

LEGO-Bench addresses the lack of precise ground truth for diverse single-image scene reconstruction. Its inputs are rendered from fully specified simulator scenes, combining natural-image-style visual complexity with access to private geometry, depth, camera parameters, instance masks, and object identities. The benchmark contains 208 RGB views from 104 logical scenes, spanning eight environments, 17 themes, and 443 registered assets. It includes indoor, outdoor, and Bird’s-Eye settings, with scene families whose object content increases from Easy to Medium to Hard while shared architecture, camera, lighting, materials, and object transforms remain fixed.

Figure 3: Representative LEGO-Bench inputs across indoor, outdoor, and Bird’s-Eye reconstruction settings.

The benchmark’s controlled construction procedure is an important methodological contribution. Difficulty is not defined solely by global object count. Instead, matched scene families add visible objects while preserving the rest of the scene, enabling comparisons that attribute performance changes more directly to scene content.

Figure 4: Scored-object counts increase within matched scene families, while object count alone is not used as the formal difficulty definition.

LEGO-Bench reports three principal metrics:

• Validity checks whether the submission contains a reloadable Blender scene, a non-empty GLB export, a renderable active camera, and a parseable non-degenerate image. Invalid or unresolved submissions receive zero for the headline metrics.
• Reconstruction measures visible-surface agreement in the reference camera frame. Reference and predicted surfaces are partitioned by private instance masks and compared without registration, rescaling, or camera fitting. The headline metric is an object-level macro-average F-score at a depth-relative tolerance of 5%.
• Appearance compares a fresh evaluator render with the reference image under a fixed rendering protocol. It captures the joint effects of geometry, camera, materials, lighting, and color configuration.

The no-alignment reconstruction metric is deliberately stringent. It penalizes incorrect camera pose, scale, object placement, missing surfaces, and excess geometry rather than absorbing these errors through post hoc registration. Appearance is complementary rather than redundant: a scene may obtain reasonable geometric agreement but render poorly because of incorrect materials or illumination, while a visually similar render may conceal geometric errors.

Figure 5: LEGO-Bench separates artifact validity, visible-surface reconstruction, and evaluator-rendered appearance.

The benchmark also includes a human validation study. Across six annotators and 240 samples, compatibility agreement was 86.6% overall, with 88.9% for reconstruction judgments and 84.3% for appearance judgments. Metric–human compatibility reached 83.7% under the study’s uncertainty rule. These results support the use of the automatic metrics, although they do not establish that the metrics capture every property of scene usefulness.

Main reconstruction results

The general-purpose coding agents achieved near-saturated artifact validity but much lower geometric and visual fidelity. GPT-6-astra was the strongest evaluated configuration, reaching an overall score of 53.4% indoors and 39.6% outdoors. Its indoor Reconstruction and Appearance scores were 52.4% and 54.4%, respectively; outdoors, they fell to 34.0% and 45.5%.

Model	Indoor validity	Indoor score	Outdoor validity	Outdoor score
GPT-6-astra	100.0%	53.4%	98.0%	39.6%
GPT-6-sol	99.4%	32.3%	99.7%	24.2%
GPT-6-luna	99.7%	23.2%	99.7%	17.3%
GPT-5.6-sol	97.8%	14.8%	98.7%	15.3%
GPT-5.6-terra	99.7%	15.4%	98.0%	11.5%
GPT-5.6-luna	99.1%	14.1%	97.0%	12.1%

The principal empirical distinction is therefore between delivering a valid executable artifact and recovering the scene faithfully. The coding agents almost always produced scenes that could be opened and rendered, but the gap between validity and fidelity remained large. GPT-6-astra’s performance exceeded that of the task-specific and single-image baselines in overall score, but this result should not be interpreted as dominance on every constituent metric. Gen3DSR, for example, achieved higher indoor Reconstruction than GPT-6-astra, 65.4% versus 52.4%, but obtained zero Appearance because its output did not provide a valid appearance reconstruction under the benchmark protocol.

Scene complexity reduced Reconstruction and Appearance without materially affecting validity. Across the evaluated GPT configurations, validity remained approximately 99.5% across complexity tiers, while overall performance declined from 24.6% on Easy scenes to 21.3% on Medium and 20.5% on Hard. The decline was particularly pronounced for outdoor Reconstruction, which fell from 18.4% to 12.7%. This result indicates that additional scene content primarily increases perceptual and geometric errors rather than causing agents to fail at artifact production.

The paper also reports a test-time reasoning experiment on a 42-case Office subset. Increasing native reasoning effort improved all three GPT-6 models. GPT-6-astra increased from 32.3% at Low effort to 61.8% at XHigh effort; GPT-6-sol increased from 21.3% to 39.7%; and GPT-6-luna increased from 14.4% to 21.2%. The gains were larger for stronger models, whereas GPT-5.6 configurations showed weak or non-monotonic scaling. The result suggests that additional inference-time computation is useful in this setting, but its effectiveness depends strongly on the underlying model.

Construction trajectories and failure mechanisms

A central strength of the paper is that it does not reduce agent behavior to a final benchmark score. By rescoring intermediate renderable artifacts, it identifies three recurrent failure modes: weak initialization, regressive edits, and unreliable self-evaluation.

GPT-6-astra reached its first evaluable scene within approximately the first tenth of its available budget, whereas GPT-5.6-sol required roughly one fifth. The difference matters because delayed initialization leaves less time for render-based refinement. After initialization, GPT-6-astra improved more consistently, while GPT-5.6-sol stagnated or regressed. In the analyzed trajectories, 29.6% of GPT-5.6-sol’s edits decreased the benchmark score, and its final result was 3.2 points below its best intermediate scene.

Figure 6: GPT-6-astra initializes earlier relative to its runtime and improves more steadily, whereas GPT-5.6-sol exhibits more frequent regression.

The non-monotonicity of construction is a substantive finding. The final artifact is not necessarily the best artifact produced during the trajectory, even when the agent has already constructed a higher-quality scene. Late edits can damage geometry, camera settings, object placement, or appearance. The paper’s severe regression example shows that this problem is not confined to weaker systems: even the strongest model can substantially degrade a scene after reaching a better intermediate state.

Figure 7: A late-stage edit can substantially reduce the quality of an already stronger scene, including for the strongest evaluated model.

The self-evaluation study reinforces this diagnosis. Across 36 builder–judge pairs, self-judgments agreed with the deterministic Reconstruction direction only 45.8% of the time, below chance, and agreed with Appearance direction 62.2% of the time. Cross-model judging produced 45.4% and 63.9%, respectively. Thus, self-judging provided no consistent advantage. Geometry was especially difficult for the models to assess, plausibly because image-level similarity does not reliably expose depth, scale, occlusion, and surface-placement errors.

This result directly challenges the assumption that a coding agent can use its own visual critique as a reliable optimization signal. The paper therefore treats reference-grounded measurements, rather than free-form model judgment, as the appropriate basis for controlled refinement.

LEGO-Plugin and training-free trajectory control

LEGO-Plugin is a harness-compatible control layer designed to address the three diagnosed failures without retraining the underlying agent. It adds three modules:

• Enhanced Initialization uses VGGT-derived camera and scene-frame estimates together with image-grounded layout cues to establish a reference-aligned starting scene.
• Grounded Refinement uses reference object regions and relative depth estimates from SAM 3 and Depth Anything V2 to produce explicit residuals for projected extent, centroid, depth order, visibility, and related constraints.
• Version Control wraps updates in transactions, snapshots scene state, checks protected entities and hard requirements, and commits, repairs, or rolls back candidate revisions.

Figure 8: LEGO-Plugin adds reference-grounded initialization, measured refinement, and transactional version control to a standard coding-agent harness.

The plugin does not access private benchmark ground truth or LEGO-Bench scores. Its evidence is derived only from the input image and current Blender state. This distinction is important because it makes the reported improvements attributable to better control and measurement rather than evaluator-specific optimization.

On the 42-case Office subset, LEGO-Plugin improved all six evaluated model configurations. The relative gains were largest for the weaker models: the GPT-5.6 variants improved by approximately 55–63%, corresponding to roughly seven to eight score points. GPT-6-luna improved by 27.5%, GPT-6-sol by 12.1%, and GPT-6-astra by only 2.1%. The inverse relationship between baseline strength and plugin benefit indicates that the plugin compensates primarily for procedural weaknesses already avoided by the strongest model.

Figure 9: LEGO-Plugin produces visibly closer reconstructions and more than doubles example scores, from 0.147 to 0.325 and from 0.109 to 0.278.

The result is strong but qualified. LEGO-Plugin improves every tested configuration under the stated protocol, yet it does not eliminate the performance gap between weaker and stronger agents. Moreover, the evaluation is concentrated on the Office subset, so the reported relative improvements do not establish equivalent gains across all environments, outdoor scenes, or Bird’s-Eye views.

Executable scenes as downstream visual representations

LEGO-World tests whether a frozen reconstructed scene can support multiple visual tasks through deterministic readouts. From the same GPT-6-astra-generated scene program, the system derives 2D object boxes, instance masks, and camera-space depth. No task-specific training is applied to the reconstructed scenes.

The results demonstrate non-trivial reuse but also substantial imprecision:

Task	LEGO-Anything	Specialist baseline
COCO box AP	30.14	59.88, DINO
LVIS mask AP	14.75	53.96, SAM 3
ETH3D AbsRel	0.1554	0.0783, Depth Anything 3

The scene-derived readouts achieve approximately half of the specialist detector’s box AP, but only a much smaller fraction of specialist instance-segmentation performance. Depth estimation is also substantially worse: AbsRel is 0.1554 compared with 0.0783 for Depth Anything 3. The comparison is subject to an explicit protocol limitation: scene-derived detections and masks have no calibrated confidence scores, so average precision uses equal confidence and a deterministic tie order. The reported AP therefore measures compatibility under that ranking policy rather than calibrated detection quality.

Coverage is also imperfect. Scene outputs were scored on 94 of 100 COCO and LVIS images and 99 of 100 ETH3D images, while all attempted images remained in the official evaluation denominators. These details matter because a frozen scene representation must support both semantic completeness and geometric accuracy to function as a general visual substrate.

The downstream results establish a narrower claim than universal task competence. Executable scenes already contain enough structure to support detection, segmentation, and relative depth without separate task-specific prediction heads. However, their errors remain too large for the representation to match specialized vision systems, particularly for object boundaries, instance identity, and precise geometry.

Limitations and open questions

The benchmark relies on simulator-rendered scenes rather than real photographs with independently measured 3D ground truth. This permits exact evaluation but introduces a domain assumption: performance on LEGO-Bench may not transfer directly to uncontrolled real imagery, where lighting, texture, sensor artifacts, asset identity, and physical irregularities differ from the simulator distribution.

Single-view reconstruction is intrinsically underdetermined. The benchmark evaluates visible-surface geometry and rendered appearance, not uniquely correct hidden geometry or complete physical scene structure. A scene can therefore score well while remaining incorrect behind occlusions. Conversely, appearance may be improved through view-specific construction that does not yield a generally accurate 3D model.

The appearance metric is a thresholded pixel agreement measure rather than a learned perceptual metric. It is sensitive to rendering configuration and evaluates a fresh standardized render, which is appropriate for artifact verification but does not fully characterize material realism or human perceptual similarity. The reconstruction metric is similarly view-conditioned and uses private reference masks to define object scopes; its validity for applications requiring semantic correspondence or interaction beyond the reference view remains open.

The downstream LEGO-World evaluation has additional methodological constraints. Equal-confidence AP is not directly comparable to calibrated detector rankings, and the scene-derived outputs have incomplete coverage. The experiments use GPT-6-astra without LEGO-Plugin, so they do not determine whether plugin-controlled scenes would produce better or worse downstream representations.

Finally, the trajectory analysis identifies regressions but does not fully isolate their causal sources. Model capability, harness behavior, token budget, tool latency, rendering frequency, and prompt configuration are coupled in the evaluated systems. The paper leaves open whether explicit checkpoint selection, learned value estimation, improved scene abstractions, or stronger geometric feedback would provide the most effective remedy.

Conclusion

LEGO-Anything formulates single-image 3D reconstruction as iterative construction of an executable Blender program. LEGO-Bench shows that coding agents can reliably produce valid scene artifacts, but that artifact validity substantially exceeds geometric and appearance fidelity. GPT-6-astra reaches 53.4% indoor and 39.6% outdoor overall scores, while trajectory analysis identifies delayed initialization, regressive edits, and unreliable visual self-evaluation as major sources of failure. LEGO-Plugin improves all six evaluated agents without training, with relative gains of up to 62.7%, especially for weaker configurations. LEGO-World further shows that reconstructed scenes support deterministic detection, segmentation, and depth readouts, although well below specialized models. The paper’s principal contribution is thus not only an Image-to-Code reconstruction system, but an evaluation framework that exposes the difference between executable artifact production, faithful scene recovery, and representation quality (2609.36380).