SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2410.21909 · 2024

SceneGenAgent: Precise Industrial Scene Generation with Coding Agent

arXiv · PDF · Open in the Atlas

Code that ran

10 of 11 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 0 honoured the contract we drafted, 3 violated it and 0 have no contract verdict; 7 failures of our instrument; 1 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2410.21909.json · badge: /api/ran/2410.21909.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
thudm/scenegenagent canonical (classifier label)
classifier basis: census
10 ran · 1 no recorded run
FunctionStatusWhere it lives
base_filter Ran
ran; our contract draft was wrong, not the code
thudm/scenegenagent/scenegenagent/cleaning.py
code served (permissive licence) · get_code("cdf6031dc56656eb")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import re

def base_filter(text):
    if len(re.findall('[\\u4e00-\\u9fff]+', text)) > 0 or text == text.upper():
        return (True, 'The description should only contain English in proper upper and lower cases.')
    return (False, None)


# The function takes a single parameter: text (a string)
# It checks if the text contains Chinese characters or is all uppercase
# We need to provide a valid string argument

ARGS = {
    'text': 'This is a valid English description with proper casing.'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
contain_coords Ran
ran, violated the contract we drafted
thudm/scenegenagent/sceneinstruct/cleaning.py
code served (permissive licence) · get_code("257edaeebfb9e475")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import re

def contain_coords(text):
    re_coord = '\\[-?\\d+(\\.\\d+)?\\s*,\\s*-?\\d+(\\.\\d+)?\\s*,\\s*-?\\d+(\\.\\d+)?\\s*\\]'
    return bool(re.findall(re_coord, text))

# The function takes a single parameter 'text' which should be a string
# It searches for coordinate patterns in the format [x, y, z] where values can be integers or floats

ARGS = {
    "text": "The coordinates are [-1.5, 2, 3.7] and also [0, -5, 10]"
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
contain_numbers Ran
ran, violated the contract we drafted
thudm/scenegenagent/scenegenagent/cleaning.py
code served (permissive licence) · get_code("caa3d6f10e84ffff")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned bool, ndim 0, dtype family float; no output shape is stated. It ran in syntology-harvest-sandbox:v5-deps (sha256:6a292aa1aed1) at 2026-09-27T00:58:14Z. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import re

def contain_numbers(text):
    re_coord = '\\[-?\\d+(\\.\\d+)?\\s*,\\s*-?\\d+(\\.\\d+)?\\s*,\\s*-?\\d+(\\.\\d+)?\\s*\\]'
    re_scalar = '(?:^|\\s)(\\d+(\\.\\d+)?\\s*m)'
    return bool(re.findall(re_coord, text)) or bool(re.findall(re_scalar, text))

ARGS = {
    'text': 'The coordinates are [-1.5, 2, 3.7] and the distance is 5.2 m'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type bool, ndim 0, dtype family float — no output shape is stated: no later run recorded an output shape for this sample (observed_output and metamorphic_properties carry none; shape_contract and output_contract record ndim only)
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image syntology-harvest-sandbox:v5-deps (sha256:6a292aa1aed1); not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
contain_scalars Ran
ran, violated the contract we drafted
thudm/scenegenagent/scenegenagent/cleaning.py
code served (permissive licence) · get_code("a4cbae0a17ddfeec")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned bool, ndim 0, dtype family float; no output shape is stated. It ran in syntology-harvest-sandbox:v5-deps (sha256:6a292aa1aed1) at 2026-09-27T00:58:14Z. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import re

def contain_scalars(text):
    re_scalar = '(?:^|\\s)(\\d+(\\.\\d+)?\\s*m)'
    return bool(re.findall(re_scalar, text))

ARGS = {
    "text": "The measurement is 5.5 m and another is 10 m long."
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type bool, ndim 0, dtype family float — no output shape is stated: no later run recorded an output shape for this sample (observed_output and metamorphic_properties carry none; shape_contract and output_contract record ndim only)
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image syntology-harvest-sandbox:v5-deps (sha256:6a292aa1aed1); not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
list_objects Ran
ran; our contract draft was wrong, not the code
thudm/scenegenagent/scenegenagent/layout_analysis.py
code served (permissive licence) · get_code("474eb72d5cb392c1")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import re

class MockModel:
    """Mock model that generates a properly formatted response"""
    def generate(self, prompt):
        return """#Step 1: Find all objects#
Analysis: The description mentions a Kuka robot, a welding table, and a conveyor system.
Objects: ["Kuka Robot KR125", "Welding Table", "Conveyor"]

#Step 2: Fix object names#
Analysis: All objects are already from the permission list and correctly named.
Objects: ["Kuka Robot KR125", "Welding Table", "Conveyor"]

#Step 3: Rewrite description#
Analysis: Rewrite as industrial modeling engineer would, keeping positional information.
New Description: A workstation consists of a Kuka Robot KR125 positioned at the center, a Welding Table located to the left, and a Conveyor system positioned to the right.
"""

def re_find(regex, text):
    return targets[0] if len((targets := re.findall(regex, text))) > 0 else None

prompt_fix_objects = 'You are given a description of a workstation, which is used to build a scene in Process Simulate (PS).\nThe original description is as follows:\n```\n{prompt}\n```\nYou should follow the steps below:\n1. First, find all objects mentioned in the description and should appear in the workstation according to the description. Objects with or without specific positions should all be listed. If the description mentions multiple instances of the same object, list the object repeatedly for each instance. For example, if "ten tables" are mentioned, then include "table" ten times. Note that a "station", a "workstation", or a "scene" is not an object.\n2. Then, fix the names of objects that are not correct. The objects that may appear in the description are from the permission list: [Kuka Robot KR125, Kuka Robot KR350, ABB Robot IRB6600, YASKAWA Robot ma01800, Welding Table, Turntable, Cabinet, ValveStand, Conveyor, Guarding]. For every object you find, change it so that it meets all the requirements:\n   - All objects found in the previous step is independent of each other. Do not merge them into one object.\n   - If the object is not from the permission list, including upper/lower cases, replace it with an object in the permission list that satisfies the restrictions in the description.\n   - If there are objects with general types, replace them with specific objects from the list.\n   - The object type must satisfy the restrictions in the description. For example, the description may state that some objects must be the same/different.\nIf the description requires you to add objects or there are no objects in the scene, add some objects that meet the description restrictions.\nOnly fix the objects that are already found and do not add additional objects.\nReturn all objects after correction, including ones that are correct and ones that are changed to be correct.\n3. Finally, you should modify the original description:\n   - Rewrite the description like an industrial modeling engineer would in accurate wordings.\n   - Include all objects found in the last step, including upper/lower cases.\n   - All objects found in the previous step is independent of each other. Do not merge them into one object.\n   - Keep the positional, directional, and orientational information of objects.\n   - Remove the color, shape, length, height, and function attributes of objects.\nReturn the rewritten description with one single sentence in one line and keep all positional information.\n\nYou should return your analysis, objects and description in the format below:\n```\n#Step 1: Find all objects#\nAnalysis: <analysis>\nObjects: ["ObjA", "ObjB", ...]\n\n#Step 2: Fix object names#\nAnalysis: <analysis>\nObjects: ["ObjC", "ObjD", ...]\n\n#Step 3: Rewrite description#\nAnalysis: <analysis>\nNew Description: <new description>\n```\nDo not say anything else.'

def list_objects(text, model_retrieve_objects):

    def parse_analysis(text):
        analysis = []
        re_steps = ['#Step 1:[\\s\\S]+?\\nAnalysis:\\s*([\\s\\S]*?)\\s*\\nObjects:', '#Step 2:[\\s\\S]+?\\nAnalysis:\\s*([\\s\\S]*?)\\s*\\nObjects:', '#Step 3:[\\s\\S]+?\\nAnalysis:\\s*([\\s\\S]*?)\\s*\\nNew Description:']
        step_names = ['Find all objects', 'Fix object names', 'Rewrite description']
        for re_step, step_name in zip(re_steps, step_names):
            as1 = re_find(re_step, text)
            if as1:
                analysis.append((step_name, as1))
        return analysis
    model_input = prompt_fix_objects.format(prompt=text)
    while True:
        text = model_retrieve_objects.generate(model_input)
        obj_lists = re.findall('Objects:\\s*(\\[.*?\\])', text)
        descriptions = [l for l in re.findall('New Description:\\s*([\\s\\S]*?)(?:$|`)', text)]
        if len(obj_lists) > 0 and len(descriptions) > 0:
            print('Objects:', text)
            print()
            analysis = parse_analysis(text)
            return (obj_lists[-1], descriptions[-1], analysis)

ARGS = {
    'text': 'A workstation with a Kuka robot, welding table, and conveyor system.',
    'model_retrieve_objects': MockModel()
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
list_objects Ran
ran; our contract draft was wrong, not the code
thudm/scenegenagent/sceneinstruct/layout_analysis.py
code served (permissive licence) · get_code("46f6d85566d998c4")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import re

class MockModel:
    """Mock model that generates formatted responses for list_objects"""
    def generate(self, model_input):
        # Return a properly formatted response that matches the expected format
        response = """#Step 1: Find all objects#
Analysis: The description mentions a Kuka Robot, a Welding Table, and a Turntable as the main objects in the workstation.
Objects: ["Kuka Robot KR125", "Welding Table", "Turntable"]

#Step 2: Fix object names#
Analysis: All objects are already from the permission list and correctly named. No changes needed.
Objects: ["Kuka Robot KR125", "Welding Table", "Turntable"]

#Step 3: Rewrite description#
Analysis: The description should be rewritten as a single sentence from an industrial engineer's perspective, including all objects and their positional information.
New Description: The workstation consists of a Kuka Robot KR125 positioned at the center, a Welding Table located to the left of the robot, and a Turntable positioned to the right of the robot.
"""
        return response

# Create a sample input text describing a workstation
sample_text = "A workstation with a Kuka robot, welding table, and turntable for automated assembly operations."

# Create the mock model instance
mock_model = MockModel()

# Define ARGS dictionary with all parameters
ARGS = {
    "text": sample_text,
    "model_retrieve_objects": mock_model
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
parse_placement Ran
ran; our contract draft was wrong, not the code
thudm/scenegenagent/scenegenagent/layout_analysis.py
code served (permissive licence) · get_code("45e27445cd21f252")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import re
import json

# The function parse_placement takes a single parameter 'text' which is a string
# It uses regex to find patterns in the text and extract JSON arrays from three steps
# The text should contain sections marked with #Step 1, #Step 2, and #Step 3
# Each section should have Objects, Positions, and Relative Positions followed by JSON arrays

text_input = """#Step 1: Analyzing the scene
Objects: ["object1", "object2", "object3"]
#Step 2: Determining positions
Positions: [[0, 1], [2, 3], [4, 5]]
#Step 3: Computing relative positions
Relative Positions: [["left", "right"], ["above", "below"]]
"""

ARGS = {
    "text": text_input
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
re_find Ran
ran; our contract draft was wrong, not the code
thudm/scenegenagent/scenegenagent/layout_analysis.py
code served (permissive licence) · get_code("1f3f9c1bc1fa03ce")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. It ran in syntology-harvest-sandbox:v5-deps (sha256:6a292aa1aed1) at 2026-09-27T00:58:14Z. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import re

# The function takes two parameters: regex (a regex pattern string) and text (a string to search in)
# re.findall() is called with the regex and text, and returns a list of matches
# The function returns the first match if any exist, otherwise None

ARGS = {
    "regex": r"\d+",
    "text": "The answer is 42 and also 123"
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image syntology-harvest-sandbox:v5-deps (sha256:6a292aa1aed1); not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
read_file_tree Ran
ran; our contract draft was wrong, not the code
thudm/scenegenagent/scenegenagent/code_gen.py
code served (permissive licence) · get_code("44aaf573b50d8c95")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import os
import tempfile
import shutil

# Create a temporary directory structure with .txt files
temp_dir = tempfile.mkdtemp()

# Create some nested directories and .txt files
os.makedirs(os.path.join(temp_dir, "subdir1"), exist_ok=True)
os.makedirs(os.path.join(temp_dir, "subdir2", "nested"), exist_ok=True)

# Write some test .txt files
with open(os.path.join(temp_dir, "file1.txt"), "w", encoding="utf-8") as f:
    f.write("content of file1")

with open(os.path.join(temp_dir, "subdir1", "file2.txt"), "w", encoding="utf-8") as f:
    f.write("content of file2")

with open(os.path.join(temp_dir, "subdir2", "nested", "file3.txt"), "w", encoding="utf-8") as f:
    f.write("content of file3")

# Also create a non-.txt file to ensure it's ignored
with open(os.path.join(temp_dir, "ignore_me.log"), "w", encoding="utf-8") as f:
    f.write("this should be ignored")

ARGS = {
    "directory": temp_dir
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
remove_punctuation Ran
ran; our contract draft was wrong, not the code
thudm/scenegenagent/sceneinstruct/minhash.py
code served (permissive licence) · get_code("6379d172938408fe")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. It ran in syntology-harvest-sandbox:v5-deps (sha256:6a292aa1aed1) at 2026-09-27T00:58:14Z. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import re

def remove_punctuation(input_string):
    punc = u'[。;,:""()、?《》.]'
    punc_en = '[!\\"#$%&\\\'()*+,-./:;<=>?@\\[\\\\\\]^_`{|}~\\n]'
    st = re.sub(punc, '', input_string)
    st = re.sub(punc_en, '', st)
    return st

ARGS = {
    'input_string': 'Hello, world! 你好;世界(test)'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image syntology-harvest-sandbox:v5-deps (sha256:6a292aa1aed1); not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
image_to_base64 Not yet run
unverified (harvested, no recorded run)
thudm/scenegenagent/scenegenagent/model.py
code served (permissive licence) · get_code("28e76dd547c37a6d")
How it ran

no invocation recorded.

Also present in other papers' code

Of 11 samples lifted from this paper's linked repositories, 11 carry a function identity and 0 do not. Of the 11 distinct functions with an identity, 0 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 0 later) and 11 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

The modeling of industrial scenes is essential for simulations in industrial manufacturing. While large language models (LLMs) have shown significant progress in generating general 3D scenes from textual descriptions, generating industrial scenes with LLMs poses a unique challenge due to their demand for precise measurements and positioning, requiring complex planning over spatial arrangement. To address this challenge, we introduce SceneGenAgent, an LLM-based agent for generating industrial scenes through C# code. SceneGenAgent ensures precise layout planning through a structured and calculable format, layout verification, and iterative refinement to meet the quantitative requirements of industrial scenarios. Experiment results demonstrate that LLMs powered by SceneGenAgent exceed their original performance, reaching up to 81.0% success rate in real-world industrial scene generation tasks and effectively meeting most scene generation requirements. To further enhance accessibility, we construct SceneInstruct, a dataset designed for fine-tuning open-source LLMs to integrate into SceneGenAgent. Experiments show that fine-tuning open-source LLMs on SceneInstruct yields significant performance improvements, with Llama3.1-70B approaching the capabilities of GPT-4o. Our code and data are available at https://github.com/THUDM/SceneGenAgent .

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("2410.21909")
get_code_for_paper("2410.21909")
have("2410.21909")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/2410.21909.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/2410.21909.svg)](https://syntology.ai/paper/2410.21909)

Connect an agent — have() is free.