Technical Summary: SR-Platform

Problem Statement

Scaling robot learning requires large collections of diverse, physically plausible simulation environments. However, constructing these environments remains a significant bottleneck. Creating a training-ready MuJoCo scene typically demands expertise in 3D asset modeling, MJCF specification, spatial layout, collision avoidance, and robot-model integration. While Large Language Models (LLMs) have shown promise in semantic reasoning and code synthesis, prior approaches often rely on fixed object libraries, stop at symbolic descriptions, or require manual intervention before execution. Consequently, the end-to-end problem of converting an unconstrained natural language prompt into a physically valid, simulator-ready robot scene remains insufficiently addressed.

Methodology: SR-Platform

SR-Platform is a production-deployed agentic system designed to synthesize executable MuJoCo environments from free-form natural language descriptions. Rather than relying on a monolithic LLM, the system employs a four-layer, typed, and auditable pipeline coordinated by a PipelineCoordinator. The architecture is deployed as a nine-service Docker stack utilizing WebSocket streaming, MinIO for mesh storage, Qdrant for semantic retrieval, Redis for state management, and InfluxDB for telemetry.

The pipeline consists of four distinct stages:

1. L1: Orchestrator
   This stage converts a user's natural language prompt (e.g., "an assembly line with a conveyor and a robotic arm") into a structured JSON scene plan. It defines room dimensions, object lists, semantic labels, the selected robot identity, and anomaly parameters. Implemented as a LangGraph workflow, it separates semantic planning from geometry generation to reduce LLM complexity and localize failures.

2. L2: Asset Forge
   The asset forge resolves object labels into simulator-compatible 3D meshes (STL). It employs a cache-first strategy:

   • Semantic Retrieval: Object labels are embedded and queried against a Qdrant vector database. If a high-similarity cached asset exists, the STL is loaded from MinIO.
   • LLM-to-CadQuery Synthesis: If no cache hit occurs, an LLM generates CadQuery code to synthesize new geometry. This code is executed to produce an STL mesh, which is then stored and indexed for future reuse.
   • Robustness: The system includes validation and automatic retry mechanisms. If generated code is malformed or geometry is invalid, the system attempts regeneration or falls back to simplified geometry to prevent job failure.

3. L3: Layout Architect
   This stage assigns spatial poses (position and rotation) to all resolved objects. It uses an LLM-based layout model to propose placements that are semantically plausible (e.g., tables on the floor) and physically consistent (no overlaps). Crucially, it integrates an IndustryRulesChecker to verify constraints such as electrical clearance, fire-safety egress, machinery safety distances, and ventilation clearance. Violations are returned as structured entries to allow for resampling or anomaly labeling.

4. L4: Bridge and MJCF Assembly
   The final stage converts the laid-out scene plan into an executable MuJoCo XML (MJCF) file. It constructs the floor, walls, and object bodies, inserting the retrieved or generated STL meshes with their computed poses. A RobotMerger integrates the selected robot model (from a catalog including UR5, Franka Panda, etc.) into the scene, ensuring coordinate-frame consistency. This stage is deterministic and does not invoke LLMs.

Key Contributions

The paper outlines four primary contributions:

1. End-to-End Agentic Pipeline: A system that converts natural language workspace descriptions into executable MuJoCo scenes containing robot models, mesh assets, object poses, and spawn coordinates.
2. Cache-Aware Asset Forge: A mechanism combining semantic retrieval with LLM-to-CadQuery generation, which reduces redundant LLM calls for previously generated object types.
3. Industrial Layout Verification: The integration of constraint checking (clearance, safety, egress) into the scene synthesis process prior to MJCF assembly.
4. Production Telemetry: Reporting on 30 days of production data covering 611 successful LLM calls, detailing per-stage latency, retry behavior, and throughput limits.

Experimental Results

The system was evaluated using production telemetry from a 30-day deployment window.

• Latency: For a five-object scene where all objects miss the cache, the median end-to-end latency is approximately 50 seconds. When objects are retrieved from the cache, latency drops to 30–40 seconds.
• Stage Performance: The L2 Asset Forge is the dominant latency contributor. The median latency for a first-attempt CadQuery generation (skill_generator) is 17.9 seconds (p95: 65.4s). Retry calls are slower, with a median of 24.4 seconds.
• Reliability: The asset forge demonstrates an 11.3% first-attempt retry rate. Failures are primarily due to malformed CadQuery code or invalid geometry. Automatic retry and fallback mechanisms allow the system to recover without aborting the entire scene generation.
• Throughput: The system supports five concurrent generation jobs. Throughput is limited by L2 asset generation but can be scaled horizontally by adding workers, as the architecture shares stateless services (Redis, MinIO, Qdrant).
• Model Performance: Benchmarks on mechanical CAD and free-form assets indicate that claude-opus-4-6-fast achieves the highest geometric accuracy for mechanical parts, while qwen3-coder-480b offers a strong balance of speed and cost.

Significance and Claims

The paper positions SR-Platform as a step toward making robot simulation environment generation more scalable and accessible. By enabling users to produce executable MuJoCo scenes from plain English prompts in under one minute, the system reduces the manual effort required to build diverse training environments.

The authors emphasize that the system's value lies in its production-oriented design: it is not merely a research prototype but a deployed service featuring real-time progress streaming, asynchronous job execution, semantic asset retrieval, and per-user state isolation. The paper claims that this agentic approach, which separates semantic planning, asset generation, layout reasoning, and simulator assembly, allows for better caching, debugging, and validation than single end-to-end LLM prompts. Furthermore, the inclusion of industrial constraint checking aims to bridge the gap between visually plausible scenes and physically valid, deployment-ready environments.

The authors modestly note limitations, acknowledging that the system currently targets indoor industrial and semi-structured environments and that LLM-generated CAD code, while recoverable, is not yet a guaranteed deterministic compiler. Future work is proposed to include image-to-3D generation, higher-fidelity physics backends, and direct export to robot-learning dataset formats.