Agent-Centred Simulator

• Agent-centred simulators are systems where autonomous agents drive simulation through modular designs, adaptive behaviors, and emergent interactions.
• They decouple agent cognition, environment modeling, and action execution via layered microkernel architectures that enable runtime intervention and plug-in extensibility.
• These simulators apply to domains like urban mobility, distributed AI, social simulation, and cyber-physical systems to achieve high fidelity and efficient benchmarking.

An agent-centred simulator is a simulation system in which individual agents—autonomous and interactively situated computational entities—are the primary unit of design, execution, and analysis. In such systems, each agent possesses internal state, decision-making protocols, and interacts through well-defined interfaces with its environment and other agents. The paradigm shifts system modeling away from monolithic, rule-based, or centrally orchestrated process descriptions to architectures where agents’ heterogeneous, adaptive behaviors drive emergent system-level dynamics. Agent-centred simulators are foundational across domains ranging from social simulation, distributed AI, process mining, urban mobility, economics, to cyber-physical systems.

1. Formal Architectures and Modular Decomposition

Agent-centred simulators are most robustly realized through modular and layered architectural designs that strictly decouple agent cognition, environment modeling, and action execution. The "Agent-Kernel" microkernel architecture exemplifies this approach, decomposing the system into four subsystems: Kernel Core (Controller, System Timer, Message Bus, Event Recorder), Cognitive Engine (agent reasoning and state), Environment Adapter (centralized, plug-in world state), and Action Executor (repositories of executable capabilities), all interlinked strictly via the Controller. Each agent operates an internal "Perceive → Plan → Invoke → State → Reflect" loop, interfacing with the environment and action modules through validated Controller APIs. The kernel supports runtime intervention, plug-in hot-swaps, and strict separation between "thinking" (LLM-driven cognition) and "doing" (state manipulation, world changes) (Mao et al., 1 Dec 2025).

Similar modular patterns appear in fog computing simulation (YAIFS), where layered abstractions—Core (discrete-event), API (domain objects), Service Interface (REST/MCP endpoints), MCP (Model Context Protocol), and LLM agent layer—structure the system and enable independently extensible agent and environment orchestration (Lera et al., 21 Apr 2026). In educational simulation (AgentSchool), agent state is factored as high-dimensional objects (episodic memory, knowledge-graph, reasoning workflows), with state transitions driven by both local policy decisions and global simulation schedules (Ye et al., 28 May 2026).

2. Agent Representations, Cognition, and Decision Making

Agent-centred simulators instantiate agents as self-contained objects or processes, each maintaining explicit internal state, decision rules, sensorimotor policies, and communication buffers. Cognition ranges from classical BDI (Belief, Desire, Intention) models with formal event-handling, ontologies, and protocol stacks (Carbo et al., 2024), through explicit knowledge-graph-based cognition (ZPD-aligned learning, misconception tracking in AgentSchool (Ye et al., 28 May 2026)), to LLM-driven prompt-planning cycles that generate, interpret, and dispatch structured actions (Mao et al., 1 Dec 2025).

In process simulation (AgentSimulator), each agent corresponds to a real resource, learning probabilistic decision tables and execution schedules from empirical logs, with autonomous vs. orchestrated handover modes selectable at simulation time (Kirchdorfer et al., 2024). In urban mobility, agents implement parameterizable preference and adaptation models (e.g., multinomial logit for traveller mode; Q-learning for driver shift choice) and learning kernels for daily adaptation (Kucharski et al., 2020). For multi-turn LLM agent serving (AGENTSERVESIM), each program is treated as a stateful, stepwise agent, driven by event-based orchestration and KV-cache state transitions across hardware tiers (Rajib et al., 8 Jun 2026). Multi-agent communication, group context formation, and event-driven memory evolution enhance realism in opinion-dynamics and societal simulation (Zhu et al., 5 Jun 2026).

3. System Dynamics, Environment Coupling, and Interaction Protocols

Core to agent-centred simulation is the bidirectional coupling between agents and environment. The system state at each tick or event is advanced via a global scheduler or event loop; each agent’s action is computed from private and shared local observables and affects the global state via validated environment interfaces. For example:

• "Universe 25" realizes time-evolving populations, where agent birth, death, and state transitions are governed by explicit vector-valued rules and updatable plugin modules; population curves follow formal counting equations (Mao et al., 1 Dec 2025).
• In cyber-physical-social platforms (SOCIA), agents are dynamically orchestrated into analysis, data cleaning, code synthesis, execution, and evaluation-feedback roles, with iterative refinement optimizing simulation realism metrics by hierarchical or distributed scheduling (Hua et al., 17 May 2025).
• Distributed ledger simulations (TangleSim) assign each node or peer agent modular components (storage, block issuance, tip management, consensus), emulating heterogeneous communication, protocol, and attack behaviors, under stochastic network and adversarial conditions (Lin et al., 2023).
• In disaster response, TOC-coupled agent-based hydrodynamic and social-force pedestrian models exchange dynamic state and hazard information through message-passing at each discrete time-step, creating strongly-coupled, adaptive evacuation and intervention dynamics (Shirvani et al., 2019).
• Multi-agent communication protocols are handled by formal context managers (e.g., MCP tools in TrafficSimAgent, YAIFS), facilitating platform-independent extensibility and decoupled inter-agent coordination (Du et al., 24 Dec 2025, Lera et al., 21 Apr 2026).

4. Simulation Control, Runtime APIs, and Interactivity

Agent-centred simulators expose powerful mid-execution control and introspection mechanisms, supporting highly interactive, adaptable workflows:

• Kernel Controllers and system modules (timers, messengers, recorders) support deterministic tick advancement, rollback, runtime parameter updates, and global event logging. All module interactions are strictly mediated for reliability and reproducibility (Mao et al., 1 Dec 2025).
• Service-oriented simulators (YAIFS) provide REST/MCP endpoints for external agent registration, event subscriptions, branching ("fork") of simulation state, execution window management, and detailed metric retrieval, all supporting agent-driven adaptive experimentation (Lera et al., 21 Apr 2026).
• LLM-augmented interfaces allow non-programmatic scenario design, leveraging RAG pipelines and specialized orchestration agents (e.g., HomeBuilderAgent, ThreatInjectorAgent) for natural-language-driven setup, verification, and execution (Siriweera et al., 2 Mar 2026).
• Hardware-aware schedulers in agent-serving simulators (AGENTSERVESIM) orchestrate multi-turn agent execution, cache residency, routing, and policy evaluation, reproducing real-system performance with high fidelity (Rajib et al., 8 Jun 2026).

5. Evaluation Metrics, Empirical Case Studies, and Comparative Results

Agent-centred simulators are systematically benchmarked against domain-specific quantitative metrics and real-world data:

• In social and campus life simulation, adaptability to population dynamics, hot-swappable modules, and deterministic execution outperform legacy frameworks in handling varying large-scale societal scenarios without kernel code changes (Mao et al., 1 Dec 2025).
• For business process simulation, agent-centric (resource-first) models significantly reduce error in control-flow, timing, and congestion metrics while improving computational efficiency compared to control-flow-first or deep learning-driven simulators (Kirchdorfer et al., 2024).
• In traffic and urban mobility, hierarchical agent designs and memory-augmented coordination yield superior performance in task generalization, traffic signal optimization, and throughput compared to monolithic or template-based systems (Du et al., 24 Dec 2025).
• For disaster response, physical and social agent coupling quantitatively alters risk and evacuation outcomes, enabling precise evacuation planning and barrier sizing by simulating intervention group size and scenario variants (Shirvani et al., 2019).
• In educational simulation, explicit cognitive structures and ZPD-aligned adaptive teaching result in differentiated mastery, more accurate misconception traces, and plausible emergent social phenomena (Ye et al., 28 May 2026).
• In agent-serving and distributed systems, precise simulation of scheduler policies, cache management, and memory tiering achieves <6% error in job-completion-time and throughput metrics relative to hardware deployments (Rajib et al., 8 Jun 2026).
• Opinion-dynamics simulation integrating event-steered and news-driven group formation matches real-world attitudinal time series with lowest bias and error among all tested models (Zhu et al., 5 Jun 2026).

6. Key Design Principles: Adaptability, Configurability, Reliability, Reusability

Agent-centred simulators explicitly embody the four "pillars" of robust MAS simulation (Mao et al., 1 Dec 2025):

• Adaptability: Hot-swap of agent, environment, or action plugins without recompilation; dynamic addition/removal of agents or entire modules at runtime.
• Configurability: Exposed runtime APIs and declarative configuration files enable on-the-fly scenario tuning, global parameter updates, and agent-specific overrides.
• Reliability: Centralized controllers enforce preconditions and input validation on every action; system timers ensure deterministic tick-synchronous advancement; queued messaging prevents deadlock and race conditions.
• Reusability: Standardized abstract interfaces for all plugins; data and schema isolation at the module/plugin level; resource-constrained and scenario-generalized workflows.

These principles are reinforced by empirical results, demonstrating the superiority of explicit, modular agent-centred designs over monolithic or ad hoc systems in accuracy, run-time efficiency, transparency, and extensibility across domains.

7. Future Directions and Limitations

Agent-centred simulators are extending towards:

• Hierarchical, distributed, and memory-augmented orchestration to support thousands of concurrent, heterogeneous agents in complex environments (Hua et al., 17 May 2025).
• Full RL-based or search-based adaptive convergence and policy tuning for automatic optimization and emergent behavior amplification (Hua et al., 17 May 2025, Du et al., 24 Dec 2025).
• Multi-modal integration (e.g., textual, graphical, sensor data), supporting richer agent perception and actuation (Du et al., 24 Dec 2025).
• Enhanced natural-language programming and interaction, lowering the domain entry threshold and enabling democratized simulator configuration (Siriweera et al., 2 Mar 2026, Lera et al., 21 Apr 2026).
• Explicit support for normativity and regulated action in institutional domains, with typed, policy-explainable communication and decision feasibility filtering (Dong, 4 Dec 2025).

Current challenges include reliance on LLM performance and prompt design for cognition-rich agents, scalability bottlenecks under centralized orchestration, and the need for further empirical validation in scenario domains beyond those tested. Ongoing research aims to implement distributed and hierarchical agent configurations, increase simulation efficiency, and systematically expand the interpretability and adaptability of agent-centred simulation systems.