RadioSim Agent: Interactive EM Simulation

• RadioSim Agent is an agentic computational framework that integrates LLM orchestration, deterministic EM ray-tracing, and vision-enabled reasoning to produce semantically rich radio map analyses.
• It converts free-form natural language prompts into structured simulation workflows by orchestrating parameter extraction, tool selection, and result interpretation.
• The framework leverages physics-based models including LOS, reflections, and NLOS to offer reproducible, interactive analyses for next-generation wireless systems.

RadioSim Agent is an agentic computational framework that unifies LLMs, deterministic electromagnetic (EM) ray-tracing solvers, and vision-enabled reasoning to deliver interactive, explainable, and semantically rich radio map analysis. Built around callable, physics-based simulation libraries orchestrated by an LLM planner (GPT-4o-mini), RadioSim Agent transforms free-form natural language prompts into automated, reproducible radio propagation analyses with multimodal interpretability. It integrates tool selection, scenario parameterization, deterministic simulation, and image-based semantic summarization within a closed workflow, targeting intelligent electromagnetic simulation assistants for next-generation wireless systems.

1. System Architecture and Data Flow

RadioSim Agent is modular, comprising:

• User Interface (UI): Accepts free-text user prompts, renders both numerical and visual simulation outputs, and relays queries to the LLM Orchestrator.
• LLM Orchestrator (Natural-Language Planner): Based on GPT-4o-mini. Parses intents, extracts structured parameters (e.g., scenario, coordinates, grid size), decomposes semantics into discrete tool calls (simulation, visualization, summarization), and seeks clarification as needed.
• EM Ray-Tracing Solver (Simulation Tool Library): Implements deterministic geometric ray-tracing and empirical models—line-of-sight (LOS), single/ground reflections (REF, GREF), empirical NLOS, building-entry loss (BEL). Exposes a Python-API:

def simulate_radio_environment( tx_x: float, tx_y: float, tx_z: float, scenario: str, nx: int, ny: int, LOS: bool, REF: bool, GREF: bool, NLOS: bool, BEL: bool ) -> SimulationResult

Results: pathloss map (dB), feature masks, full metadata.

• Vision Analysis Module (Vision Reasoning Tool): Utilizes GPT-4o-mini’s multimodal engine. Consumes rendered heatmap images and returns a textual semantic summary (e.g., “regions of high/low pathloss, gradients near walls”). API:

def summarize_pathloss_image(image_path: str) -> str

• Execution & Output Module: Conducts tool calls in sequence, logs all input/output for reproducibility, and delivers summary reports and data to the UI.

Block Diagram:

[User Prompt] | (LLM Orchestrator) | +------> [Simulation Tool Library] | +------> [Vision Analysis Module] | [Execution & Output] | UI

This architecture allows conversion of natural language objectives into detailed simulation workflows, with semantic, visual, and numerical deliverables (Hussain et al., 8 Nov 2025).

2. LLM–Simulator Integration and Workflow Automation

The LLM Orchestrator serves as a reasoning and workflow engine. Key operational steps:

• Intention Parsing: LLM parses free-form user prompts into a structured, JSON-like parameter set: target scenario, transmitter (TX) coordinates, grid resolution, enabled propagation mechanisms.
• Workflow Planning: LLM decomposes intent into a linear sequence of tool calls (e.g., “simulate → summarize_image → compose_report”). If ambiguity exists, clarification dialogues are initiated.
• Simulation Execution: The orchestrator invokes the deterministic solver (simulate_radio_environment) with full parameters, receiving a pathloss map and associated feature maps.
• Vision Reasoning: The output heatmap is passed to the Vision Analysis Module for semantic interpretation.
• Report Assembly: The orchestrator collates raw outputs and semantic summaries into the final answer, which is delivered via the UI.

Pseudocode example:

user_prompt = get_user_input() plan = LLM.parse_and_plan(user_prompt) for step in plan: if step.tool == "simulate_radio_environment": sim_res = simulate_radio_environment(**step.params) elif step.tool == "summarize_pathloss_image": summary = summarize_pathloss_image(step.params["image_path"]) final_answer = LLM.compose_final_answer(sim_res, summary) display_to_user(final_answer)

This approach encapsulates logic for both scientific reproducibility (all I/O logged in metadata) and multimodal output delivery.

3. Radio Propagation Modeling and Simulation Details

RadioSim Agent’s deterministic core fuses geometric and empirical radio propagation models relevant for realistic built environments:

• Friis Free-Space Model:

$$P_r = P_t\,G_t\,G_r \left(\frac{\lambda}{4\pi\,d}\right)^2$$

Where $P_t$ is transmit power, $G_t$, $G_r$ antenna gains, $\lambda$ wavelength, and $d$ path length.

• Ray-Tracing with Reflections: For each receiver (RX) grid point, geometric path enumeration computes direct (LOS), single- and ground-bounce reflections with individual received power calculated via the Friis formula, modulated by path-dependent reflection coefficients ($\rho$).
• Empirical NLOS and Building Entry Loss (BEL): For RX points where geometric paths are blocked, a 3GPP-style NLOS model is used:

$$PL_{\text{NLOS}}(d) = PL_{\text{ref}} + 10\,n\log_{10}\!\left(\frac{d}{d_{\text{ref}}}\right)$$

BEL (ITU-R P.2109) applies fixed per-wall penetration losses to rays crossing buildings.

• Scene Management: Five canonical urban scenes (Munich01, Munich02, London, Helsinki, Manhattan) are pre-loaded.

The simulation API produces:

• $n_x \times n_y$ pathloss map (dB)
• Feature masks: LOS regions, reflection areas, 3D distance, building/height/azimuth attributes
• Comprehensive simulation metadata (parameters, timing, random seeds)

These outputs form the basis for visualization and further multimodal analysis.

4. Heatmap Generation, Analysis, and Semantic Vision Integration

The framework’s visualization and postprocessing stack includes:

• Core Outputs:
  • Pathloss heatmap (colormapped, PNG)
  • Feature overlays (masks for LOS/reflections, building outlines)
  • Quantitative metrics: min/max/mean pathloss, percentile contours, regional statistics
• Optional Post-Processing:
  • Gaussian spatial smoothing for presentation
  • Edge detection to emphasize sharp pathloss gradients
  • Regional binning (e.g., quadrants) for statistical summarization

Vision Analysis Module leverages LLM-based visual reasoning to provide semantic heatmap summaries:

1. Localizes regions with “cool” (low pathloss) colors near the transmitter as LOS-dominated.
2. Identifies “hot” bands (high loss) behind buildings as NLOS/shadowed regions.
3. Detects sharp gradients along walls as reflection phenomena.

Example Vision Tool output: “The lower-left quadrant exhibits strong signals (110–120 dB), while the upper-right quadrant is dominated by high attenuation (160–170 dB). Sharp gradients align with major building blocks, indicating significant wall reflection and shadowing effects.”

This closed semantic loop enables non-expert users to obtain domain-relevant insight beyond raw data arrays (Hussain et al., 8 Nov 2025).

5. Example Interactive Scenario and End-to-End Operation

The agentic workflow is illustrated with an urban UAV scenario:

• Prompt: “Simulate pathloss in the Munich01 scenario with a UAV at (100, 100, 15) over a 50×50 receiver grid considering all propagation mechanisms, and provide a concise technical summary.”
• LLM Extraction: Parses scenario, TX location, grid, activates all propagation mechanisms.
• Simulation: Runs deterministic solver; outputs pathloss PNG.
• Vision Reasoning: Consumes PNG, produces: “Pathloss ranges from 110 dB (strong) to 170 dB (weak). Strong signals cluster in the lower-left quadrant; weak regions appear upper-right. Gradients near walls highlight reflection loss.”
• LLM Composition: Final report returned: “Simulation completed. The heatmap shows a 110–170 dB range; strongest signals lie in the SW quadrant near the UAV, while the NE quadrant is heavily shadowed. Reflection-induced gradients coincide with major building facades.”

This illustrates an end-to-end path from user intent to domain-specific technical conclusions.

6. Reproducibility, Deployment, and Extensibility

RadioSim Agent is fully open-source (https://github.com/sajjadhussa1n/radio-sim-agent), enabling community extension and verification. Key aspects:

• Reproducibility: All runs are logged with parameter and output metadata, supporting scientific audit trails.
• Extension: New urban layouts, propagation mechanisms, or semantic descriptors can be incorporated by extending the simulation and vision tool APIs.
• Computational Considerations: The use of pre-cached scenes and bounded grid resolution allows interactive throughput. Resource usage is moderate and compatible with standard workstation hardware.
• Integration: The natural language interface and visual reasoning modules are compatible with a broad class of LLMs that expose function calling and vision capabilities.

By bridging deterministic simulation, advanced LLM reasoning, and vision-enabled postprocessing, RadioSim Agent demonstrates a converged architecture for explainable, interactive EM radio simulation suitable for both research and engineering practice (Hussain et al., 8 Nov 2025).