SimWorld Embodied Agent Simulator

Develop and evaluate multimodal autonomous agents in realistic physical and social worlds.

Stars
★ 787
Last updated
3mo ago
License
Apache-2.0
Primary language
Python

At a glance

How it runs
Library / SDKSelf-hosted service
Works with
Portable with changesOpenAI API (Partial support)
Cost
Free software; you pay for model usage
Setup effort
High · needs real infrastructure
You'll need
Python 3.10 or laterUnreal Engine server packageWindows or LinuxDedicated GPU with at least 6GB VRAM32GB RAM50-200GB disk spaceShell / CLINetwork accessLocal filesystem
Typical use
Embodied-AI researchers evaluating VLM navigation, planning, or object interaction in physically simulated urban and indoor scenes.
Not a fit if
  • Developers without a dedicated GPU or 50-200GB of disk space
  • Users wanting a single-command run without launching a separate UE server

What does this agent do, and when should you use it?

SimWorld is an Unreal Engine 5 simulation platform for developing and evaluating LLM/VLM agents in complex physical and social environments. Its three-layer architecture combines an Unreal Engine backend, an environment layer for city and traffic generation, and an agent layer that reasons over multimodal observations and executes planned actions. The Python package includes Communicator, Humanoid, Map, BaseLLM, a local action planner, city generation, traffic, weather, and asset-retrieval components. Agents can consume position, orientation, RGB, depth, or segmentation observations and interact through movement, rotation, pickup, sitting, and other documented action types. Deployment spans a local Python client and a separately launched UE server; the required Base package supplies two lightweight city maps and one empty map, with more than 100 optional prebuilt maps.

A typical run connects to an active Unreal Engine server with Communicator(UnrealCV()), constructs a Humanoid, and places it in the world through communicator.spawn_agent. The environment reads position and orientation through UnrealCV and obtains visual input with communicator.get_camera_observation, producing observations such as position, direction, and an egocentric image. In the navigation example, BaseLLM("gpt-4o") turns the observation and target into a textual action; the environment parses that action and invokes communicator.humanoid_step_forward or communicator.humanoid_rotate. Other APIs can place objects with communicator.spawn_object, procedurally build a city with communicator.generate_world, and remove environment objects with communicator.clear_env. YAML configuration controls the seed, time step, UE blueprint paths, city generation, traffic, asset retrieval, and agent/model options; a task loop can return updated multimodal observations, a distance-based reward, and success state.

  1. Embodied-AI researchers evaluating VLM navigation, planning, or object interaction in physically simulated urban and indoor scenes.
  2. Robotics teams testing pedestrian, vehicle, or robot behavior in UE environments before deciding whether to run physical trials.
  3. Multi-agent researchers constructing traffic and social scenarios for cooperation, strategic reasoning, and behavior evaluation.
  4. Simulation and data engineers collecting structured RGB, depth, and segmentation observations for training or benchmark experiments.
  5. Unreal Engine developers bringing existing maps, assets, or character models into a Python-controlled simulator through custom .pak files.
  6. Teaching and prototyping teams demonstrating autonomous navigation with the Base maps and a Gym-like reset/step loop.

How do you install or deploy this agent?

The documented requirements are Windows or Linux, Python 3.10 or later, a dedicated GPU with at least 6GB VRAM, 32GB RAM, and 50–200GB of disk space depending on the package.

Install the Python client:

git clone https://github.com/SimWorld-AI/SimWorld.git
cd SimWorld
conda create -n simworld python=3.10
conda activate simworld
pip install -e .

Download and extract the Base UE server package for the operating system. Base is required and includes two city maps plus one empty map. Optional environments are distributed as separate .pak files and should be copied into SimWorld/Content/Paks/ under the Base server directory. For custom settings, run cp config/example.yaml config/your_config.yaml, fill in the local paths, and load it with Config('path/to/your_config') using an absolute path. The example constructs BaseLLM("gpt-4o"), but the supplied material does not document the required API credential variable, configuration key, or credential-acquisition procedure.

How do you use this agent?

Start the UE server before running Python code. On Windows, double-click SimWorld.exe or run ./SimWorld.exe <MAP_PATH>; on Linux, run ./SimWorld.sh <MAP_PATH>. <MAP_PATH> is an Unreal Engine internal map path such as /Game/hospital/map/demo.umap. If it is omitted, the server opens /Game/Maps/demo_1.

With the server running, execute an example under examples/ or open examples/gym_interface_demo.ipynb. A minimal loop creates Communicator(UnrealCV()), calls communicator.spawn_agent from reset() to place a Humanoid, and reads position, orientation, and camera output. It then repeatedly asks the agent for an action and passes it to step(action), which invokes movement or rotation APIs and returns the next observation and reward. Separate examples cover city layout generation, traffic simulation, asset retrieval, cameras, and direct UE commands. Custom maps, objects, and agent models must first be packaged as .pak files and installed in the server's Paks directory.

What are this agent's strengths and limitations?

Pros
  • The UE5 backend combines realistic rendering and physics with procedural cities, traffic simulation, and agent control in one architecture.
  • Observation support includes position, orientation, RGB, depth, and segmentation, while the action space covers pedestrians, vehicles, and robots.
  • The small Base package supports initial testing, while more than 100 separately packaged .pak maps can be installed selectively.
  • Custom UE environments, assets, and agent models can be imported, extending the simulator beyond its bundled content.
  • Gym-like interaction and concrete Communicator APIs support navigation tasks, reward functions, and automated evaluation loops.
Limitations
  • Adoption has substantial hardware and storage costs: at least 6GB of dedicated VRAM, 32GB RAM, and 50–200GB of disk space.
  • The Python package is not a complete standalone runtime; it depends on a separately downloaded and launched UE server.
  • The example selects gpt-4o, but credential setup, model costs, rate limits, and model-call failure handling are not documented in the supplied material.
  • A unified training and evaluation framework, RL pipeline, 1K-plus city-scale multi-agent simulation, and MuJoCo integration remain roadmap items.
  • Arbitrary natural-language grounding into UE actions is not yet complete; the shown workflow parses a constrained action string and calls explicit APIs.

How does this agent compare with similar options?

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
SimWorld Embodied Agent Simulator This agent 42 · Major gaps Library / SDKFree + model costs ★ 787 3mo ago Python —
RLinf RL Infrastructure 35 · Major gaps Library / SDKFree ★ 5.4k 1d ago Python —
EDSL (Expected Parrot Domain-Specific Language) 63 · Some gaps Library / SDKFree + model costs ★ 497 4d ago Python OpenAI API · Claude API
MobileGym 50 · Major gaps CLIFree + model costs ★ 800 5d ago Python —

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Major gaps
42/ 100 5-point scale 2.1 / 5
Trust 4/29
Reliability 5/14
Adaptability 12/18
Convention 10/18
Effectiveness 7/13
Verifiability 4/8
Why each dimension lost points
Trust4 / 29 · 0.7/5

The README gives a basic account of the Python client, UE backend, LLM, camera observations, and action commands, and it exposes effects such as generation, movement, spawning, and environment clearing. This earns limited data-flow and external-effect credit. Deductions apply because there is no least-privilege model, pre-action confirmation, sensitive-data or API-secret policy, dependency integrity/vulnerability control, or recoverable rollback procedure; clear_env is a destructive cleanup API rather than rollback. Repository, documentation, paper, and community references provide partial attribution, but the object names SimWorld-AI while one badge points to maitrix-org, and publisher identity is unverified, so provenance remains limited.

Reliability5 / 14 · 1.8/5

The architecture, setup, configuration, and usage levels are broadly coherent. However, the quick example is explicitly simplified and references uninitialized or undefined values including self.config, self.map, agent_bp, agent_name, duration, observation, position, and success, so it is not a complete internally consistent implementation. Python, operating systems, hardware, UE packages, and startup order are documented adequately, but the large external binaries lack checksums, pinned versions, or an offline alternative. No exception handling, diagnostic workflow, or user-facing failure messages are shown.

Adaptability12 / 18 · 3.3/5

The material thoroughly identifies audiences and scenarios spanning quick tests, 100-plus map expansion, custom UE environments/assets/agents, navigation, traffic, generation, and multimodal research. The roadmap distinguishes current from planned capabilities, although a comprehensive agent framework, arbitrary-language actions, RL, and city-scale multi-agent support remain unfinished. Action triggering is only illustrated through startswith parsing and omitted code, without a strict grammar, validation, or ambiguity handling. Windows/Linux, Python, GPU, memory, disk, configuration overrides, and custom packages are documented, but broader platform compatibility and resource-degradation options are not.

Convention10 / 18 · 2.8/5

Architecture, project tree, quick tour, setup, configuration, API references, customization, and roadmap are organized clearly, justifying full information-architecture credit. Installation guidance is concrete but relies on external UE packages and linked documentation and lacks locked versions, checksums, and complete troubleshooting. Naming/provenance is weakened by the SimWorld-AI versus maitrix-org link inconsistency and the absence of a stability policy. A minimal example and examples directory are supplied, but there is no FAQ and the shown example is incomplete. Hardware requirements and unfinished roadmap items disclose some limitations, but known failures and operational boundaries are not systematically documented. The complete Apache-2.0 text earns full license credit. News entries are not a formal versioned changelog; contribution and Slack links suggest an update path, but the supplied sources do not identify maintainers, support commitments, or release ownership.

Effectiveness7 / 13 · 2.7/5

The Gym-like interface, observation structure, action calls, configuration path, and API index are practically useful for research prototyping, while physical/social simulation, extensible maps, and multimodal agent interfaces offer meaningful value beyond generic agent scaffolding. Deductions reflect the heavily abbreviated central example and absence of source-backed benchmark outcomes, task results, or output-quality evidence. The README candidly states requirements of at least 6GB VRAM, 32GB RAM, and 50–200GB storage, but provides no installation-time, runtime, model/API cost, or benefit comparison.

Verifiability4 / 8 · 2.5/5

Major capabilities are commonly tied to project directories, examples, code locations, configuration files, documentation, or a paper, giving good claim traceability. Cross-source corroboration is limited because only README and LICENSE contents are supplied here, so the referenced code, documentation, paper, and demonstrations cannot be compared within this assessment. Existing features, optional extensions, and unfinished roadmap items are generally separated clearly, but promotional claims such as accurate physics, seamless integration, and robustness lack supporting measurements or qualifications in the supplied evidence.

Risks and how to mitigate them
  • Not found in source: least-privilege scopingGrant only what the task needs: a dedicated account or read-only token, scoped to specific directories and repos.
  • Not found in source: confirmation before actingTurn on (or add) a confirmation step before it acts, and try it in a sandbox or test environment before real data.
  • Not found in source: sensitive-data handlingUse dedicated, low-privilege, revocable API keys — never production credentials — and keep secrets out of logs.
  • Not found in source: dependency securityPin versions and run a dependency audit (npm audit, pip-audit) before installing; prefer running it in a container.
  • Not found in source: rollback or recovery pathBack up first, or work on a git branch or snapshot, so its changes can be undone.
  • The quick-tour code is abbreviated and contains several undefined or uninitialized values; it should not be treated as directly runnable.
  • The UE server and maps are large external downloads; independently verify their source, version, licensing, and file integrity before installation.
  • No policy is shown for API keys, sensor data, prompts, or other sensitive-data handling and retention.
  • Spawn, movement, world generation, and clear_env mutate simulator state, but the material provides no confirmation gate, transaction boundary, or recovery procedure.
  • Hardware and storage costs are substantial, while no performance benchmark or cost-benefit evidence supports scaled adoption.
  • Repository, badge, and publisher attribution signals are not fully consistent; maintenance ownership and the authoritative release channel require separate confirmation.
Evidence confidence: Low Reviewed Sep 21, 2026 Reviewed revision 1f588ec94699
Review evidence README.mdLICENSE
See the full review method →

FAQ

Can I run SimWorld after installing only the Python package?
No. The Python client connects to a SimWorld UE server that must be downloaded and started first; the Base server package is required.
Is GPT-4o mandatory?
The minimal example uses BaseLLM("gpt-4o"), but the architecture targets LLM/VLM agents and does not document ready-made adapters for other providers. Switching models may require configuration or integration work.
What environments are included in the basic installation?
The Base package includes two lightweight city scenes and one empty map. More than 100 additional environments are optional downloads installed as separate .pak files.
Can I use my own Unreal Engine content?
Yes. Custom environments, assets, and agent models can be packaged as .pak files and imported into SimWorld.
Does it already provide a complete RL and large-scale multi-agent training pipeline?
No. The unified agent training and evaluation framework, RL pipeline, and city-scale simulation with more than 1,000 concurrent agents are listed as future work.
View on GitHub ↗ Install ↓

Related agents