LLMs Writing 3D Scripts Directly: A New Paradigm for 3D Creation

Over the past year, the on-paper capabilities of foundation models have gradually converged, and the competitive focus has clearly shifted toward post-training and the depth of deployment in vertical scenarios. Evaluation results released recently by multiple organizations send a clear signal: large language models are no longer content with “answering questions correctly”—they are starting to “get real work done” in real software environments, locating and fixing defects in the command line, building complex scenes in professional 3D software, and cross-checking financial documents running to hundreds or thousands of pages. This article does not target any specific product. Instead, it breaks down the general technical logic behind this capability leap, helping developers understand the trend, choose the right path, and avoid detours.

1. Post-Training: The Engineering Foundation of the Capability Leap

1. What post-training actually does. Through massive pretraining, a base model acquires the “chassis” of language, knowledge, and reasoning. To become a reliable productivity tool, however, it needs multiple layers of post-training: supervised fine-tuning injects task formats, domain knowledge, and instruction-following ability; reinforcement learning from human feedback (RLHF) aligns output preferences; and the rapidly popularizing reinforcement learning with verifiable rewards (RLVR) uses objective signals—whether code passes tests, whether a script runs successfully, whether a numerical derivation is correct—as rewards, teaching the model to self-correct over long-horizon tasks.

2. Why the gains can be large. A base model’s capabilities are unevenly distributed, and much of its potential lies dormant. Post-training uses high-quality task trajectory data to chain single-step reasoning ability into multi-step execution ability. Agent tasks in particular require an “observe–decide–act–correct” loop, and this capability depends almost entirely on trajectory design and reward engineering during post-training. That is why, after a round of post-training iterations, open-source models can jump straight into the first tier on multiple professional benchmarks.

3. The gains concentrate in “verifiable” domains. Code, scripts, and numerical computation share one trait: success or failure can be automatically judged by a machine, so the training signal is cheap, dense, and scalable. This explains why the current leap has appeared first in tasks such as terminal execution and direct 3D script writing, rather than in areas like aesthetics or creativity that are hard to quantify.

2. Terminal Coding: The Litmus Test for Agent Capabilities

1. What terminal benchmarks actually measure. Not “write a piece of code,” but complete a full set of engineering actions in a real command-line environment: understand the repository structure, install dependencies, reproduce the issue, read logs, modify multiple files, run tests, handle failures, and finally commit. It is a classic long-horizon task chain, where a single environmental misjudgment at any step leads to total failure. Recent public evaluations show that top open-source post-trained models now sit in the same first tier as the strongest closed-source models on terminal tasks—something hard to imagine a year ago.

2. Cost now ranks alongside accuracy. For the same terminal task, completion cost can differ severalfold across models, driven mainly by inference length, the number of tool calls, and retry frequency. A growing number of teams select models through a two-dimensional “accuracy versus cost per task” lens: simple tasks go to lightweight models, complex tasks escalate to flagship models, and tiered routing balances experience against cost.

3. Deployment essentials. When wiring a terminal agent into a real workflow, engineering safeguards matter more than raw model capability:

• Sandbox isolation: all commands run in controlled containers with restricted network and file-system access;
• Least privilege: write and delete operations require explicit confirmation;
• Full audit trail: every command and its output are replayable and auditable;
• Human review: critical changes keep a human sign-off checkpoint.

The agent’s core loop can be expressed in minimal pseudocode:

while not task.finished():
    obs = sandbox.exec(task.next_action())  # Execute the action in a controlled sandbox
    task.reflect(obs)                       # Adjust the next step based on the output

3. Direct 3D Script Writing: Generative AI Enters Spatial Creation

1. The pain points of traditional 3D creation. Professional 3D software has a steep learning curve and lengthy modeling workflows, and much of the work is repetitive: laying out ground planes, placing vegetation, tweaking materials, setting up lights. For lightweight needs such as short videos, e-commerce product displays, and rapid prototypes, the cost structure of the traditional pipeline is unfriendly.

2. How direct script writing works. Mainstream 3D and industrial design software generally provide scripting interfaces that expose scene graphs, geometry, materials, lights, and cameras to developers. This means that as long as a model can write a correct script, it can drive the software to build the model—essentially “describing the world with code.” Recent public evaluations show that top models, with tool support, can already score above 90, and the best open-source models are closing in on the closed-source first tier.

3. Why “direct script writing” beats a “tool-calling middle layer.” Early solutions needed to maintain an external tool-calling protocol that mapped natural language to predefined interface calls, which limited flexibility, lengthened the chain, and added latency. Direct script writing instead hands the entire modeling process to the model, which generates code in one pass:

• Loops and randomization are expressed natively in code—a single script can batch-generate dozens of trees, each with a different shape;
• Parametric modeling turns “make the canopy 10% bigger” into changing a single number;
• A script is an asset that can be reviewed, modified, re-run, and put under version control—advantages that black-box operations cannot offer.

The following is illustrative pseudocode (the interfaces are generic placeholders, not the API of any specific software):

scene = Scene()
ground = scene.add_plane(size=(50, 50))
ground.material = Material(color="#88aa66", roughness=0.9)
for _ in range(30):                        # Batch-generate randomized trees
    x, z = random_point_in(ground, margin=5)
    trunk = scene.add_cylinder(radius=0.3, height=3.5, position=(x, 0, z))
    crown = scene.add_icosphere(radius=1.6, position=(x, trunk.height, z))
    crown.material = Material(color=jitter("#3f7d3a", spread=18))
scene.lighting.preset("overcast")          # Soft overcast sky light to soften hard shadows
scene.render(output="indoor_forest.png", samples=256)

4. Where spatial reasoning gets hard. 3D tasks place far higher demands on a model than 2D images: coordinate systems and orientation, units and scale, occlusion relationships, the physical plausibility of center of gravity and support, and aesthetic judgment of composition and lighting—an error at any point is exposed in the rendered result. This is why 3D benchmarks are regarded as a leading indicator of spatial reasoning ability.

5. From model capability to creation tools. A productization trend worth watching: model capabilities are being packaged into a complete pipeline of “online preview—online editing—export and delivery.” A generated model can be adjusted online, and once finished it can be exported as a 3D-printable file or rendered into a video or animated image for direct sharing. For creators who cannot code, the barrier to entry has been substantially lowered; for professional teams, the time from requirement to first draft has been compressed from days to minutes.

4. Financial Document Analysis: Retrieval, Cross-Checking, and Multi-Step Reasoning

1. Why finance is a high-value litmus test. Financial documents have three traits: long (prospectuses and annual reports often run to hundreds of pages), dense (tables and numbers are highly concentrated), and high-stakes (a wide variety of reporting bases and near-zero tolerance for error—any mistake gets amplified by downstream decisions). They stress-test a model’s long-document processing, structured understanding, and numerical rigor all at once.

2. Three core capabilities where the gaps are widening. Recent evaluations on real financial documents generally revolve around three points:

• Retrieval: precisely locating key disclosure passages across massive amounts of cross-document content;
• Cross-document verification: aligning the same metric from different files to a consistent basis and identifying contradictions and anomalies;
• Multi-step numerical reasoning: deriving conclusions step by step from raw data according to accounting and business logic, rather than “jumping to the answer in one step.”

3. From single-point Q&A to complete workflows. Another class of evaluations now covers the full investment analysis chain: target screening, financial quality analysis, earnings estimation, and risk flags. Top models’ progress on such end-to-end tasks shows that models are evolving from “retrieval Q&A machines” into “analysis assistants.”

4. Hallucination control is the lifeline of financial scenarios. Stress tests show that top models’ error rates have fallen from over 20% in the previous generation to single digits. Common technical approaches include:

• Retrieval augmentation with citation tracing: every conclusion must link back to its source text and be click-verifiable;
• Numerical validators: independently re-checking calculation chains—unit conversions (thousands, millions, percentages) are a frequent source of errors;
• Refusal calibration: when evidence is insufficient, explicitly answering “cannot be determined” instead of fabricating a plausible-looking number;
• Verifiable-reward training: checking results against rules and real data so the model develops a “better not to answer than to answer wrongly” preference.

5. Practical Advice for Developers and Enterprises

1. Select by task fit, not a single leaderboard. A model strong at terminal execution is not necessarily equally strong at long-document analysis. The most reliable approach is to build a small private evaluation set from your own business’s real tasks—twenty or thirty cases with standard answers often say more than chasing general leaderboards.

2. Weigh cost and performance together. Establish a two-dimensional “accuracy versus cost per task” evaluation, combined with tiered routing: the routing layer first judges task difficulty, sending simple requests to lightweight models and escalating complex requests to flagship models.

3. Make good use of cloud infrastructure. Cloud platforms—Baidu AI Cloud among them—have standardized LLM capabilities into Model-as-a-Service (MaaS) offerings, typically covering model experimentation, fine-tuning, application orchestration, logging, and monitoring and alerting, so developers can close the loop from prototype validation to production deployment without building their own inference clusters. In scenarios involving private data, prefer a “retrieval augmentation + citation tracing” architecture to keep hallucination risk down, rather than expecting the model to memorize everything in its parameters.

4. Treat model output as a “reviewable draft.” Run code in a sandbox with tests, preview 3D scripts frame by frame, and verify financial conclusions against their citations one by one. The stronger the model, the more important it is to keep human review checkpoints at critical nodes—that is the golden division of labor between humans and machines at the current stage.

Conclusion

From terminal execution to direct 3D script writing to financial-grade document analysis, the common thread of this capability leap is that models have begun operating “real-world interfaces” directly. Verifiable tasks, executable scripts, and traceable conclusions are becoming the new yardstick of model productivity. Will 3D creation break out of its niche because of this? The answer may already be written in the first modeling script generated by a model and signed off by a creator. For developers, the best strategy right now is not to wait and watch, but to pick a real business scenario and get this new toolchain running end to end.