SCSimulator: LLM-Driven Supply Chain Simulation

• SCSimulator is an LLM-driven framework that models supply chain partner selection using multi-agent simulation and multi-objective game theory.
• It features a robust architecture with backend LLM logic and interactive visual analytics views to support explainability and human-in-loop control.
• Empirical case studies show promising accuracy and expert validation, while planned extensions aim to improve scalability and negotiation capabilities.

SCSimulator is an umbrella term that has been used for several independent simulation frameworks across disparate scientific and engineering domains. Most notably, the term denotes (1) an LLM-driven visual analytics platform for supply chain partner selection (Gao et al., 21 Jan 2026), (2) a RISC-V SystemC-TLM microcontroller simulator (Montón, 2020), and (3) the CloudSimSC serverless computing simulator (Mampage et al., 2023). This article focuses on the SCSimulator framework for supply chain multi-agent simulation as introduced in "SCSimulator: An Exploratory Visual Analytics Framework for Partner Selection in Supply Chains through LLM-driven Multi-Agent Simulation" (Gao et al., 21 Jan 2026), while briefly noting related usages.

1. Mathematical Foundations and Problem Definition

SCSimulator models the partner selection process within dynamic supply chain (SC) networks as a multi-objective dynamic game. Formally, an SC at time $t$ is represented as a directed graph $G^t = (V, E^t)$, where $V$ is the set of firms and $E^t \subseteq V \times V$ are directed supply links. Each firm $i \in V$ maintains partner (supplier) and customer sets at $t$, $P_i^t$ and $C_i^t$, subject to constraints $|P_i^{t+1}| \leq K_i^{\max}$, $|C_i^{t+1}| \leq L_i^{\max}$.

Each firm $i$ seeks to optimize a linear multi-criteria utility:

$$U_i^t = \alpha_i\,\mathrm{Tech}_i^t + \beta_i\,\mathrm{Op}_i^t + \gamma_i\,\mathrm{Rep}_i^t - \delta_i\,\mathrm{Cost}_i^t,$$

where constituent features (technology, operations, reputation) are aggregated from $i$ and its partners and weighted according to $\alpha_i, \beta_i, \gamma_i, \delta_i$ with $\sum \alpha_i + \beta_i + \gamma_i + \delta_i = 1$. Partner-selection decisions $\Delta P_i^t \in \{-1, 0, +1\}^{|V|}$ encode link additions and removals. Game-theoretic integration is achieved by admitting only mutual collaborations, governed by bilateral payoffs $\Pi_{ij}^t = \Delta U_i^t + \Delta U_j^t$. Optimal link changes are computed as agent best-responses under degree and anticipation constraints.

Multi-Criteria Decision-Making (MCDM) is performed using weighted-sum models:

$$S_{i\to j}^t = \sum_{k \in \{\mathrm{Tech}, \mathrm{Op}, \mathrm{Rep}\}} w_{i,k} f_k(j),$$

directly supporting agent-level candidate ranking within the dynamic game.

2. System Architecture and Core Components

The SCSimulator system comprises:

• Backend Engine: Manages data preprocessing ("Map Data"), LLM-driven agent logic, a predictive explainability model (temporal network embedding $\rightarrow$ regressor $+$ SHAP), and the Horizon Extend Model for time-series feature forecasting.
• Frontend Interface: Features five coordinated views—Upload Page, Control Panel (adjusts all simulation and model parameters), Global View (network timeline and edge states), Focus View (egocentric "berry orchard" visualization), Adjustment View (CoT log trees and override controls), and Simulation Path View (supports rollback and branching).

Agent behavior is implemented by embedding mainstream LLMs (e.g., ChatGPT-4o) as firm-persona agents via prompt engineering. Reasoning proceeds through four serialized logic stages: Plan (CoT), Query (candidate selection via weighted features), Request (collaboration proposals), and Reply (proposal handling).

3. Multi-Agent Simulation Workflow

The simulation operates in discrete rounds as follows:

1. Initialization: Construct $G^0$ from user input, assign features $\mathbf{x}_i^0$, and configure simulation hyperparameters (reference length $R$, time horizon $T$).
2. Iteration: For each step $1 \leq t \leq T$,
   • Each agent executes Plan (LLM-CoT), Query (weighted candidate filtering), Request (propose new/removal links), Reply (respond to incoming requests), updating network state via matched mutual agreements.
   • State updates: adjacency matrix $A^{t+1}_{ij}$ is revised only when both sides accept, features evolve as $$\mathbf{x}_i^{t+1} = \mathcal{H}_i(\mathbf{x}_i^{t-R+1},\ldots,\mathbf{x}_i^{t})$$.
3. Logging: CoT rationales and decision artifacts are persistently recorded for interpretability, supporting human-in-the-loop diagnostics and intervention.

Pseudocode outline:

for t in 1..T: for each firm i: Plans_i = LLM.Plan(G^{t-1}, Knowledge_i) Queries_i = LLM.Query(Plans_i) for each firm i: Requests_i = LLM.Request(Queries_i) for each firm i: Replies_i = LLM.Reply(Requests_received_by_i) E^t = UpdateEdges(E^{t-1}, Requests, Replies) x^{t} = HorizonExtend(x^{t-1:t-R})

4. Visual Analytics, Explainability, and Human-in-the-Loop Control

SCSimulator emphasizes interpretable, interactive analytics. Key features include:

• Global View: 2D temporal network embedding, with edge colors denoting collaboration phases (initiate, maintain, terminate).
• Focus View: Egocentric timeline ("berry orchard") visualizations, integrating a central "sun" glyph for firm metrics, peripheral suppliers/customers with SHAP-influenced layout, and colorimetric encoding of relationship state.
• Adjustment View: Tree-structured display of all CoT rationales and actions per agent, with controls to Negate, Add, Delete, or Reset individual agent actions.
• Simulation Path View: Branching node diagram captures all simulation rounds, supports rollback and exploration of alternative futures.

SCSimulator unifies qualitative Chain-of-Thought (CoT) logs and quantitative SHAP (Shapley Additive Explanations) at both the global and firm level. This hybridization provides transparency and grounds for expert override or interactive correction, mitigating risks of LLM over-autonomy.

5. Evaluation: Case Studies and Empirical Results

A documented industry case study uses the paper packaging sector. The experiment involved $35$ anonymized firms with quarterly feature snapshots and network connections derived from public tender and bid data. Over $80$ simulated runs (4 key nodes, 4-step history $\rightarrow$ 1-step prediction), ChatGPT-4o agents achieved $72.4\%$ accuracy, $68.2\%$ precision, $59.8\%$ recall, $F_1 = 63.1\%$, and Gwet’s AC1 of $85.2\%$. Consistency exceeded $0.8$ for $91\%$ of firms.

Expert assessments (N=10) indicated high perceived reasonableness at CoT Plan (mean $4.3/5$), candidate filtering ($3.7/5$), reply logic ($4.7/5$), and knowledge adherence ($4.4/5$). User study participants (N=12) rated usability elements positively (ease of use $4.0/5$, effectiveness of view components $4.2$–$4.6/5$). Key challenges noted included the abstraction of the "berry orchard" metaphor and the need for finer-grained agent control (Gao et al., 21 Jan 2026).

6. Limitations and Future Directions

SCSimulator currently targets exploratory, heuristic simulation rather than exact or predictive optimization. Practical agent count is limited to 30–50 for usability and cognitive scalability, with larger deployments requiring hierarchical groupings or novel abstractions. LLM inference creates latency and cost burdens; use of API-based agents may be mitigated by private LLMs or lighter architectures.

Proposed extensions include retrieval-augmented generation for grounding agent prompts, more expressive game-theoretic and negotiation modules (e.g., multi-round bargaining, contract simulation), and flexible user authority over agent autonomy [Feng et al. 2025; Ma et al. 2025]. Open questions remain for empirical validation against real-world supply chain outcomes, scalable visualization, and integration of risk or regulatory dimensions into the core game model (Gao et al., 21 Jan 2026).

7. Related SCSimulator Frameworks

SCSimulator is also a designation for other high-fidelity simulation systems:

• SystemC-TLM–based RISC-V SoC simulator: A minimal, extensible ISS for emulating RV32IMAC cores and peripherals, supporting FreeRTOS and riscv-compliance out-of-the-box (Montón, 2020).
• CloudSimSC serverless cloud simulation: A CloudSim extension designed for policy evaluation in serverless (FaaS) environments with resource scheduling, auto-scaling, and detailed event/microservice tracing (Mampage et al., 2023).

Each of these frameworks is independent, and the use of the "SCSimulator" label should always be resolved with reference to the relevant domain and publication.

---

SCSimulator, as introduced for supply chain analytics, represents a hybridization of LLM-driven multi-agent simulation, explainable AI, and interactive visual analytics, with mathematical foundations in multi-objective game theory and MCDM, and empirically validated in industrial studies (Gao et al., 21 Jan 2026).