SR-Platform: Autonomous Scene Synthesis

• SR-Platform is a modular, production-deployed pipeline that transforms natural language prompts into physically validated MuJoCo simulation environments.
• It uses a four-stage process integrating LLMs, CadQuery-based 3D mesh synthesis, collision checking, and deterministic MJCF assembly to build robot workspaces.
• Performance metrics indicate median scene generation times of 50 seconds with efficient caching and an 11.3% first-attempt retry rate, ensuring robust synthesis.

SR-Platform refers to a production-deployed, modular, agentic pipeline that converts free-form natural language descriptions of robot workspaces into fully executable, physically validated MuJoCo environments. SR-Platform automates the conversion of plain-text prompts into MuJoCo (MJCF) XML scene specifications, including robot models, 3D object meshes, spatial layouts, collision checking, and safety-rule enforcement, making it a key system for simulation-based robot learning and synthetic data generation (Lim et al., 14 May 2026).

1. Architectural Overview

SR-Platform consists of a four-stage pipeline, supported by a nine-service Dockerized backend and a web-based interactive frontend. The architecture is natively agentic, decomposing environment synthesis into modular services:

1. L1 Orchestrator (Scene Planner):
   • Receives free-form English prompts via the frontend.
   • Utilizes a LangGraph-based workflow, with a single LLM call structured to produce a normalized JSON "scene plan," which is then validated against a schema.
   • Output includes room geometry, robot identity, a list of N semantic object types (e.g., "lab_bench," "optical_microscope"), and configuration options.
2. L2 Asset Forge (Mesh Resolver):
   • For each object label, computes a text embedding and queries the Qdrant vector DB for cached STL meshes.
   • On cache miss, invokes an LLM to generate CadQuery code for 3D mesh synthesis (automatic code execution, mesh validation, STL upload to MinIO, caching of new embeddings).
   • Employs an automatic retry mechanism with a first-attempt retry rate of 11.3% for mesh generation.
3. L3 Layout Architect (Pose Assignment & Safety Checker):
   • Assigns poses to each mesh instance, enforcing collision-free layouts using AABB overlap checks.
   • Integrates industry-specific rule checkers (clearances, fire egress, machine-robot distance, airflow requirements), with automatic resampling or anomaly marking.
4. L4 Bridge & MJCF Assembly (Scene Builder):
   • Collects prior outputs and generates deterministic MJCF XML with all asset, body, geom, and robot integration details.
   • Robot models (e.g., "ur5") are merged using a registry and insertion policy consistent with the workspace context.

The entire system operates as an asynchronous actor pipeline interconnected by Redis-backed job queues, WebSockets for real-time streaming, and REST/gRPC/S3 connections to Qdrant, MinIO, PostgreSQL, and InfluxDB for asset, job state, and telemetry management.

2. Software Stack and Workflow

The platform is composed of the following core services, each containerized:

Service Name	Function	Key Interfaces
Frontend	Prompt entry, MJCF visualization, progress display	React, MuJoCo-WASM, WebSocket
Backend API	REST/WebSocket, user and job state	FastAPI, Redis, PostgreSQL
Worker Pool	L1–L4 pipeline execution	ARQ for task queueing
Qdrant	Semantic mesh cache/index	gRPC API
MinIO	STL mesh artefact storage	S3 HTTP
PostgreSQL	Metadata, user, asset storage	SQL
Redis	Job queue, per-user scene state	Redis
InfluxDB	Telemetry: job, LLM timings, retry statistics	Time-series API
pgAdmin	Database management	Web UI

Prompt flow: User submits prompt → Backend (enqueue job in Redis) → Worker executes L1–L4 (calls Qdrant and MinIO, records to InfluxDB and PostgreSQL) → Progress/report events streamed via WebSocket → Final MJCF artefact pulled by frontend, rendered with MuJoCo-WASM.

3. Performance Metrics and Telemetry

SR-Platform has been production-evaluated over 30 days (611 successful LLM calls). Key quantitative findings (Lim et al., 14 May 2026):

• End-to-end latency:
  • Median ≈ 50 s for five-object scenes (all cache miss).
  • Cache-accelerated scenes (all cache hits) complete in ≈ 30–40 s.
• Latency breakdown:

$$T_{\mathrm{total}} = T_{\mathrm{orchestrator}} + \sum_{i=1}^N (T_{\mathrm{asset\,forge},\,i} + T_{\mathrm{layout},\,i}) + T_{\mathrm{bridge}}$$

• $T_{\mathrm{orchestrator}} \approx 16\ \text{s}$ (median)
• $$T_{\mathrm{asset\,forge},\,i} \approx 17.9\ \text{s}$$ LLM + CadQuery, $0\ \text{s}$ (cache hit)
• $T_{\mathrm{layout},\,i} \approx 16\ \text{s}$
• $T_{\mathrm{bridge}} < 1\ \text{s}$
  • First-attempt retry rate:

$$\text{retry\_rate} = \frac{\text{failed first attempts}}{\text{total asset requests}} = \frac{34}{300} \approx 11.3\%$$

• Skill generator (L2), p50 = 17.9 s, p95 = 65.4 s; Layout/unknown (L1+L3), p50 = 15.9 s.

Caches eliminated LLM overhead for previously generated object types, underscoring production suitability for interactive robot-scene generation.

4. Scene Synthesis Pipeline: Data Flow and Example

A natural-language prompt, such as "a small laboratory scene: lab bench under a window, optical microscope on the bench, pipette rack and beaker next to it, rolling stool in front, and a UR5 robot mounted at bench’s left end", is processed as follows:

1. **