Paper deep dive
VISA: A Structured Description Protocol for Agent-Based Simulation Models Towards Machine Reproducibility
Zhou He
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 93%
Last extracted: 8/3/2026, 9:30:23 AM
Summary
The paper introduces VISA, a structured, symbol-based description protocol for Agent-Based Models (ABMs) designed to enhance machine reproducibility. VISA utilizes eight interconnected tables across agent and model levels to specify model components unambiguously. It includes nineteen executable consistency rules and three LLM-executable skills (authoring, checking, code generation) to operationalize the reproduction loop. The protocol was validated on three external ABMs, successfully reproducing two models across languages and capturing a third while identifying proprietary barriers.
Entities (15)
Relation Signals (14)
VISA → enables → Machine Reproducibility
confidence 98% · VISA: A Structured Description Protocol for Agent-Based Simulation Models Towards Machine Reproducibility
VISA → consistsof → Variable
confidence 95% · Table 2 (Variable) catalogs every state variable
VISA → consistsof → Sensing
confidence 95% · Table 3 (Sensing) defines the information access structure
VISA → consistsof → Internal Function
confidence 95% · Table 4 (Internal Function) describes the behavioral rules
VISA → consistsof → Associated Data
confidence 95% · Table 5 (Associated Data) documents all external data sources.
VISA → consistsof → Input/Output
confidence 95% · Table 6 (Input and Output) specifies model-level inputs and output indicators.
VISA → consistsof → Schedule
confidence 95% · Table 7 (Schedule) defines the temporal execution sequence.
VISA → consistsof → Validation
confidence 95% · Table 8 (Validation) establishes credibility assessment criteria.
VISA → consistsof →
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Agent-based models (ABMs) are difficult to reproduce: their behavior is spread across prose narratives, platform-specific code, and implicit assumptions, so that two readers routinely reconstruct different models from the same documentation. We present VISA, a structured, symbol-based description protocol that specifies a model in eight interconnected tables---four at the agent level (Agent, Variable, Sensing, Internal Function) and four at the model level (Associated Data, Input/Output, Schedule, Validation)---under the principle of minimality with completeness. VISA makes a model machine-parseable and unambiguous via two artifacts: nineteen executable consistency rules that turn model validity into a checkable property, and three reusable LLM-executable skills (authoring, checking, and code generation) that operationalize the full author--check--code--reproduce loop. We validate the protocol on three external, independently authored ABMs spanning three platforms: we reproduce two cross-language (NetLogo to Python) directly from their VISA specifications, and we capture a third, an industrial AnyLogic model, in eight tables (passing all nineteen rules) while honestly demarcating where reproduction is blocked by a proprietary movement library and unavailable data---itself a transparency contribution. VISA moves the reproduction barrier from the model, where it is invisible, to a named, localized dependency, where it is actionable.
Tags
Links
- Source: https://arxiv.org/abs/2607.28027v1
- Canonical: https://arxiv.org/abs/2607.28027v1
Trouble viewing inline? Open PDF directly →
Full Text
200,414 characters extracted from source content.
Expand or collapse full text
VISA: A Structured Description Protocol for Agent-Based Simulation Models Towards Machine Reproducibility Zhou He hezhou@ucas.ac.cn University of Chinese Academy of Sciences, Beijing, China Abstract Agent-based models (ABMs) are difficult to reproduce: their behavior is spread across prose narratives, platform-specific code, and implicit assumptions, so that two readers routinely reconstruct different models from the same documentation. We present VISA, a structured, symbol-based description protocol that specifies a model in eight interconnected tables—four at the agent level (Agent, Variable, Sensing, Internal Function) and four at the model level (Associated Data, Input/Output, Schedule, Validation)—under the principle of minimality with completeness. VISA makes a model machine-parseable and unambiguous via two artifacts: nineteen executable consistency rules that turn model validity into a checkable property, and three reusable LLM-executable skills (authoring, checking, and code generation) that operationalize the full author–check–code–reproduce loop. We validate the protocol on three external, independently authored ABMs spanning three platforms: we reproduce two cross-language (NetLogo to Python) directly from their VISA specifications, and we capture a third, an industrial AnyLogic model, in eight tables (passing all nineteen rules) while honestly demarcating where reproduction is blocked by a proprietary movement library and unavailable data—itself a transparency contribution. VISA moves the reproduction barrier from the model, where it is invisible, to a named, localized dependency, where it is actionable. Keywords: Agent-based modeling 1 Introduction Agent-based modeling (ABM) has emerged as a powerful methodology for studying complex systems across diverse domains, including ecology [24, 53], economics [19, 2], epidemiology [15, 61], urban planning [8, 18], supply chain management [10, 60], and public policy [38, 26]. Unlike equation-based approaches, ABM enables the representation of heterogeneous agents, their adaptive behaviors, and the emergent macro-level phenomena arising from micro-level interactions [53, 37]. This bottom-up paradigm has proven particularly valuable in complex management systems, where organizational actors exhibit diverse decision-making strategies and interact within institutional constraints [44, 55]. Despite the widespread adoption of ABM, the field continues to face a fundamental reproducibility challenge [17, 46, 57]. A model that cannot be unambiguously understood and independently reproduced undermines the scientific credibility of simulation-based research [6, 13]. This challenge is especially acute for ABM because, unlike analytical models, agent-based models involve numerous design choices regarding agent behaviors, interaction topologies, scheduling mechanisms, and parameter configurations that must be precisely communicated for faithful replication [12, 68]. The difficulty is further compounded by the diversity of modeling platforms—NetLogo [64], Repast [44], Mesa, and others—each with distinct programming paradigms and abstractions [11]. Recognizing this challenge, the simulation community has developed several documentation protocols, reporting guidelines, and model-sharing platforms. The ODD (Overview, Design concepts, Details) protocol, first proposed by Grimm et al. [21] and subsequently updated [22, 23], has become the de facto standard for describing agent-based models. ODD organizes model descriptions into seven elements across three blocks, providing a structured narrative that guides authors through model purpose, state variables, process scheduling, and submodels. Several extensions have been proposed to address specific modeling aspects: ODD+D adds a decision-making module [42], ODD+2D incorporates data description for empirical ABMs [34], the Visual ODD approach [59] aims to improve the visual communication of model structures, and vODD-D provides visual documentation for data-driven models [35]. Beyond the ODD family, the MR POTATOHEAD framework offers a conceptual design pattern for structuring ABM components [47, 48], the TRACE protocol focuses on model evaluation and testing [20], and the STRESS guidelines address empirical simulation reporting [40]. UML-based representations [9] offer an alternative visual formalism for specifying model structures. On the infrastructure side, model repositories such as the CoMSES Computational Model Library (formerly OpenABM) have been established to host and share agent-based models, promoting code-level reproducibility and systematic archiving practices [31]. Despite these valuable efforts, the fundamental question of what information must be documented for a model to be faithfully reproduced remains only partially addressed. While these protocols have significantly advanced the state of model documentation, several fundamental limitations persist. First, existing protocols are predominantly text-centric—they rely on natural language narratives to describe model components, which inevitably introduce ambiguity and interpretation variability. As noted by Grimm et al. [23], even with the ODD protocol, readers often struggle to extract precise specifications sufficient for independent model reimplementation. Second, most protocols are not machine-readable—they lack the structured, symbol-based representation that enables automated parsing and code generation. This limitation becomes increasingly critical as large language models (LLMs) offer new opportunities for automated model construction and replication [32]. Third, existing frameworks exhibit redundancy and overlap among their descriptive elements, which can lead to inconsistent specifications and increased documentation burden. Fourth, there is a disconnect between model descriptions and their computational implementation—the gap between a narrative description and executable code remains wide, requiring substantial manual effort and domain expertise to bridge [41]. To address these limitations, we propose VISA, a table-based, symbol-driven description protocol for agent-based simulation models. The name reflects the paired structure of the protocol across two levels: the Agent level comprises four tables—Variable, Sensing, Internal Function, and Agent—that capture the micro-level structure and behavior of individual agents; the Model level comprises another four tables—Input/Output, Schedule, Associated Data, and Validation—that describe the macro-level configuration, data flow, temporal dynamics, and credibility assessment of the simulation. Each table employs mathematical notation, explicit cross-references, and standardized schemas that are both human-interpretable and machine-parseable. At its core, this work addresses a fundamental scientific question: what are the essential elements of an agent-based model, and what information is indispensable for reproducing its simulation results? Existing protocols such as ODD cover a broad range of elements, yet for many classic models (e.g., Schelling’s segregation model), numerous ODD items are either absent or redundant, suggesting that not all elements carry equal weight for reproducibility. In contrast, VISA is designed under the principle of minimality with completeness—every element in the eight tables is indispensable, and together they constitute the necessary and sufficient conditions for a model to be unambiguously understood, faithfully reproduced, critically evaluated, and productively extended by subsequent researchers. The main contributions of this paper are as follows: • We propose the VISA protocol, a structured, table-based description standard comprising eight interconnected tables—four at the agent level and four at the model level—built on symbol-based notation and the principle of minimality with completeness. • We demonstrate VISA through a running example based on a multi-newsvendor inventory management system, illustrating how each table captures essential model elements. • We define nineteen consistency rules that govern the relationships among the tables, turning model validity from a matter of judgment into a checkable property. • We operationalize the protocol through two artifacts: nineteen executable consistency rules and three reusable skills (authoring, checking, and code generation) that together advance transparency, reproducibility, and verifiability. • We validate the protocol empirically by running the full author–check–code loop on three external, independently authored ABMs spanning three platforms—reproducing two cross-language (NetLogo → Python) and capturing the third (AnyLogic) as an expressiveness and honest-limit case. The remainder of this paper is organized as follows. Section 2 reviews related work on ABM documentation protocols and reproducibility. Section 3 presents the VISA protocol in detail, including its design principles, notation, the eight standardized tables illustrated through a multi-newsvendor example, and the nineteen consistency rules. Section 4 operationalizes the protocol through its two artifacts—the nineteen consistency rules and the three skills—and states how evaluators and reproducers use them. Section 5 empirically evaluates the protocol by reproducing three external agent-based models. Section 6 discusses visualization and the protocol’s applicability to learned agents, together with limitations and future directions. Section 7 concludes. 2 Related Work This section reviews the landscape of reproducibility research and documentation standards for agent-based modeling. We organize the discussion along three dimensions: empirical evidence on the reproducibility challenge, existing documentation protocols and reporting standards, and efforts to bridge model descriptions with computational implementations. 2.1 Reproducibility of Agent-Based Models The reproducibility crisis documented across scientific disciplines [17, 46] poses particularly acute challenges for simulation-based research [57]. Unlike analytical models that can be fully specified by closed-form equations, agent-based models involve numerous interacting components—agent types, state variables, behavioral rules, interaction topologies, scheduling mechanisms, spatial representations, and stochastic elements—each of which must be precisely communicated for faithful replication [53, 37], a task made harder by the stochastic, emergent character of agent-based dynamics, whose outcomes are intrinsically difficult to repeat [36]. Empirical replication studies have consistently demonstrated the severity of this challenge. The seminal alignment study by Axtell et al. [6] compared independent implementations of the same model and found that even when two implementations produced qualitatively similar outcomes, quantitative discrepancies frequently arose from subtle differences in scheduling order, numerical precision, and boundary condition handling. Edmonds and Hales [13] reinforced these findings, concluding that successful alignment required far more implementation-level detail than was typically communicated in publications. Donkin et al. [12] attempted to replicate complex agent-based models following structured guidelines and characterized the task as “formidable,” identifying incomplete behavioral specifications and ambiguous interaction rules as primary sources of replication failure. More recently, Zhang and Robinson [68] proposed a formal replication standard and applied it to an existing model, finding that even with explicit guidelines, key information about scheduling, stochasticity handling, and agent activation order was often missing from original descriptions. The diversity of ABM platforms further complicates reproducibility. Daly et al. [11] and Abar et al. [1] surveyed agent-based modeling tools and documented substantial heterogeneity in their abstractions for scheduling, spatial representation, agent interaction, and data management. Models described using the conceptual vocabulary of one platform (e.g., NetLogo’s ask semantics [64]) may be difficult to translate into another (e.g., Repast’s discrete-event scheduling [44]) without losing behavioral fidelity. Mueller et al. [41] identified this platform-dependence as a key barrier to standardized model documentation. Analyses of publication practices have quantified the extent of the documentation gap. Angus and Hassani-Mahmooei [3] surveyed agent-based modeling publications in JASSS and found that a significant proportion lacked sufficient information for independent model reimplementation, even when structured documentation guidelines were available. These findings collectively underscore the need for documentation standards that are not only comprehensive in scope but also precise and unambiguous in specification. 2.2 Documentation Protocols and Reporting Standards 2.2.1 The ODD Protocol and Its Extensions The ODD (Overview, Design concepts, Details) protocol, introduced by Grimm et al. [21] and updated in 2010 [22] and 2020 [23], has become the most widely adopted standard for describing agent-based models. ODD organizes model descriptions into seven elements grouped into three blocks. The Overview block comprises Purpose, State Variables and Scales, and Process Overview and Scheduling. The Design Concepts block addresses theoretical considerations including emergence, adaptation, objectives, learning, prediction, sensing, interaction, stochasticity, and collectives. The Details block covers Initialization, Input Data, and Submodels. The protocol has had substantial impact on documentation practices across ecology, social sciences, and economics [50, 51, 62]. Its adoption has been credited with improving the completeness and comparability of model descriptions [23]. However, several limitations have been identified. Mueller et al. [41] observed that despite ODD’s availability, many published descriptions remain incomplete, and the protocol’s reliance on natural language narratives leaves considerable room for interpretation. The 2020 update [23] acknowledged that “readers often struggle to extract precise specifications sufficient for independent model reimplementation,” and introduced refinements to reduce ambiguity. Furthermore, ODD’s Design Concepts block contains elements (e.g., emergence, collectives) that are relevant primarily to certain theoretical perspectives and may be absent or redundant for many applied models. Several extensions address specific aspects. ODD+D [42] adds a module for human decision-making (decision algorithms, behavioral theories, learning); ODD+2D [34] adds a data-description module linking variables to empirical sources; Visual ODD [59] and vODD-D [35] add standardized visualization for narratives and data flow; and Bersini [9] advocates UML for representing ABM structures. While these extensions address important gaps, their proliferation has introduced a new challenge: modelers must navigate multiple overlapping standards, and the combined documentation burden has grown without a corresponding improvement in reproducibility rates [41]. 2.2.2 Other Documentation and Evaluation Frameworks Several alternative frameworks address other parts of the modeling lifecycle. The MR POTATOHEAD pattern [47, 48] decomposes ABMs into modular elements (agents, environment, rules, interactions) and aids interdisciplinary design [29], but focuses on conceptual design rather than a complete replication-ready specification. The TRACE protocol [20] and its “evaludation” extension [5] structure model evaluation and testing across the modeling cycle, ensuring credibility without specifying how a model itself is described. The STRESS guidelines [40] structure the reporting of simulation studies generally, and economics-focused proposals [54, 66, 25] call for standardized description of agent characteristics and interactions. None of these, however, fixes a machine-readable set of information elements sufficient to reproduce an ABM. 2.2.3 Model Repositories and Infrastructure Complementing documentation protocols, infrastructure-level efforts have promoted code-level reproducibility through model sharing and archiving. The CoMSES Computational Model Library (formerly OpenABM) provides a centralized repository for hosting agent-based models with standardized metadata [31]. Janssen’s analysis of archiving practices revealed that while code availability improves reproducibility, source code alone is often insufficient for understanding a model’s conceptual foundation—the same model implemented in different languages may differ in subtle but consequential ways. Janssen et al. [30] had earlier called for a community framework to support shared modeling practices. Related standardization efforts include MIASE (Minimum Information About a Simulation Experiment) [63], which defines the minimum information required to reproduce computational biology simulations, and the FAIR (Findable, Accessible, Interoperable, Reusable) principles [65], which provide general guidelines for scientific data stewardship. While these initiatives address important aspects of reproducibility infrastructure, they operate at a different level of abstraction from model description protocols and do not specify the particular information elements required for an ABM to be faithfully reproduced. 2.3 Bridging Description and Implementation A persistent and largely unresolved challenge in ABM research is the gap between model description and computational implementation. Smaldino [56] analyzed the general process of translating verbal theories into formal models, identifying numerous implicit decisions and assumptions that arise during formalization. For ABMs, Mueller et al. [41] explicitly identified the disconnect between narrative descriptions and executable code as a major barrier to reproducibility. Several approaches have attempted to narrow this gap. Ontology-based methods aim to provide formal, machine-readable representations of model components. Polhill and Gotts [49] explored the use of ontologies for integrated human-natural system modeling, and Polhill [52] developed a NetLogo extension for extracting OWL ontologies from agent-based models. While conceptually promising, these approaches have seen limited adoption due to their technical complexity and the overhead they impose on modelers. Literate programming [33] offers an alternative approach by interleaving documentation and code. However, literate programming has not been widely adopted in the ABM community, and its focus on documenting implementation rather than specifying conceptual models limits its applicability for inter-platform reproducibility. The emergence of large language models (LLMs) has introduced both new opportunities and new urgency for structured model specifications. Kazieva [32] investigated LLM-based replication of agent-based models and found that the quality and structure of the model description significantly affect reproduction success rates. This finding suggests that structured, symbol-based specifications—which reduce ambiguity and provide clear cross-references—could substantially improve the feasibility of automated model reproduction. 2.4 Summary The existing landscape of ABM documentation reveals significant progress alongside persistent gaps. The ODD protocol and its extensions have established a culture of structured documentation, while infrastructure such as CoMSES has promoted code sharing. However, three fundamental limitations remain. First, existing protocols are predominantly text-centric, relying on natural language that introduces interpretation variability. Second, the proliferation of extensions has created redundancy and overlap, increasing documentation burden without proportional gains in reproducibility. Third, no existing protocol provides a complete, symbol-based specification that is simultaneously human-readable and machine-parseable, directly bridging conceptual description and computational implementation. VISA addresses these gaps through an alternative paradigm: a table-based, symbol-driven protocol designed for completeness, minimality, and machine interpretability. 3 The VISA Protocol VISA organizes the complete specification of an agent-based simulation model into eight interconnected tables across two levels. The protocol is designed around three principles: completeness—every element necessary for unambiguous model reproduction is captured; minimality—no redundant or optional elements are retained; and machine interpretability—symbol-based notation and explicit cross-references enable automated parsing and code generation. To illustrate how each table is constructed, we use a multi-newsvendor inventory system as a running example throughout this section. In this model, multiple vendor agents compete by setting retail prices and ordering from a single wholesaler; a customer agent allocates demand via a multinomial logit rule; and an environment agent manages vendor entry and exit. 3.1 Protocol Overview The eight VISA tables are divided into two levels that mirror the fundamental architecture of agent-based models (Figure 1). The Agent level (Tables 1–4) specifies the micro-level structure and behavior of individual agents. Table 1 (Agent) enumerates all agent types and their roles. Table 2 (Variable) catalogs every state variable with its classification and provenance. Table 3 (Sensing) defines the information access structure—which agent observes which variables from which other agents. Table 4 (Internal Function) describes the behavioral rules that process information, make decisions, and update agent states. The Model level (Tables 5–8) describes the macro-level configuration and evaluation of the simulation. Table 5 (Associated Data) documents all external data sources. Table 6 (Input and Output) specifies model-level inputs and output indicators. Table 7 (Schedule) defines the temporal execution sequence. Table 8 (Validation) establishes credibility assessment criteria. Figure 1: Structure of the VISA protocol. Eight tables are organized into Agent-level VISA (blue background) and Model-level VISA (orange background). Solid gray arrows indicate intra-level relationships; dashed violet arrows indicate cross-level connections, annotated with the consistency-rule IDs they realize (r15 input–output coverage, r16 schedule coverage, r19 data-reference resolution). The ABM box groups the core simulation components. The four within-table rules (r1–r4) and the full formal predicates are in Tables 9–10. The tables are interconnected through explicit cross-references (Figure 1). Within the Agent level, variables (Table 2) serve as both inputs to and outputs of functions (Table 4), forming a bidirectional dependency: functions constitute the logic that governs variables, while variables provide the state that functions read and update. Sensing (Table 3) determines what information from other agents is available as the basis for functions. Between the two levels, the Input section of Table 6 assigns values to exogenous variables in Table 2, while its Output section computes indicators from endogenous variables. Table 7 (Schedule) orchestrates the execution of functions from Table 4. Within the Model level, Table 5 provides data for Table 6 inputs and Table 8 benchmarks. 3.2 Notation Conventions A defining feature of VISA is the systematic use of mathematical symbols to describe agents, sets, variables, and functions. Existing protocols such as ODD rely primarily on natural-language narratives to communicate model structure, which inevitably introduces ambiguity and interpretation variability [23]. By adopting a formal notation system, VISA ensures that every model element is expressed unambiguously, facilitating both human understanding and machine parsing. The conventions below draw on standard practices in management science and operations research, and are designed to map naturally to object-oriented programming constructs (e.g., class vs. instance). • Agent-type sets are denoted by calligraphic uppercase letters (e.g., V for the set of all vendors, ℰE for the environment). This corresponds to the concept of a class in object-oriented programming. • Agent instances are denoted by lowercase italic letters with subscripts (e.g., viv_i for the i-th vendor instance, e for the single environment instance). This corresponds to an object instantiated from a class. • Exogenous parameters and aggregate quantities are denoted by uppercase italic letters (e.g., N for population size, D for demand, T for time horizon). These are model-level inputs that remain constant or are drawn from specified distributions. • Endogenous variables are denoted by lowercase italic letters with subscripts and carry a time index t (e.g., qi,tq_i,t for the order quantity of vendor viv_i at step t, xi,tx_i,t for an agent’s position). These are agent-level state variables whose values are determined within the simulation and therefore evolve over time; the time index is written explicitly in Table 2 (where each variable is defined) and may be suppressed in equations and running text for readability. • Vectors and matrices are denoted by boldface (e.g., id_i for the vector of historical demand observations of vendor viv_i). • Reserved indices: The letters i,j,ki,j,k are reserved for indexing agent instances; t for simulation time steps. • Cardinality: N denotes a fixed, predetermined number of instances (e.g., N=1N_W=1 wholesaler); n denotes a variable number of instances that may change during simulation (e.g., n_V vendors, where vendors can enter or exit). These conventions are applied consistently across all eight VISA tables and throughout the remainder of this paper. 3.3 Agent-Level Description 3.3.1 Table 1: Agent The Agent table establishes the model’s ontology by enumerating all agent types, their functional roles, descriptions, and population sizes (Table 1). The Name column identifies each agent type; the Set column assigns the corresponding calligraphic symbol; the Instances column shows representative instance symbols. The Category field classifies each agent into one of four system roles: Environment An agent with two duties: managing the lifecycle of other agent instances (creation, removal, ordering) and computing model-level statistics and output aggregates (e.g., a mean price, a Gini coefficient). Parameters and state that genuinely belong to a specific decision-maker are attributed to that decision-maker, not stored on the Environment. Space An active agent that owns the spatial or topological geometry of the world (dimensions, boundary conditions such as edge wrapping, a room layout) and maintains the spatial or topological relationships among the currently-alive agent instances—a grid that returns the agents within a vision range, or a network that exposes each agent’s neighbors—and typically answers spatial-query functions for the other agents, rather than being a passive container. Decision-maker An agent that executes behavioral rules and makes autonomous choices based on its internal state and sensed information. Passive An agent that serves as a static information carrier without autonomous behavior or decision-making capability. A defining trait of VISA is that the agent taxonomy reflects the model’s own semantics, not the host platform’s object graph: only entities that behave autonomously become agents. Two things that platform code frequently exposes as separate classes are therefore not agents—a simulation output datum (e.g., a finalized contact record) is data produced by a function and is modelled as an Environment aggregate or a T6 output, and reference / lookup data (a registry, a survey, a template library) is a dataset recorded in T5. Correspondingly, a parameter read by several decision-makers is attributed to each of those types rather than parked on the Environment. The Quantity column specifies the number of instances, using N for fixed counts and n for variable counts (agents that may be created or destroyed during simulation). Table 1: VISA Table 1: Agent types and roles (multi-newsvendor example) Name Set Instances Category Description Quantity Environment ℰE e Environment Manages vendor entry/exit; computes the average price Nℰ=1N_E=1 SensingNet S s Space Maintains the vendor network topology; answers neighbor queries N=1N_S=1 Wholesaler W w Passive Provides wholesale price N=1N_W=1 Vendor V v1,v2,…v_1,v_2,… Decision-maker Decides order qty. and retail price under demand uncertainty n_V Customer C c Decision-maker Allocates demand to vendors via multinomial logit N=1N_C=1 3.3.2 Table 2: Variable The Variable table provides a complete specification of the model’s state space by cataloging every state variable for every agent type (Table 2). Each variable is classified by Type along two dimensions (Figure 2): Exogenous-homogeneous A variable whose value is provided from outside the model and is identical across all agent instances. Exogenous-heterogeneous A variable whose value is provided from outside the model but varies across agent instances (e.g., drawn from a distribution). Endogenous-decision A variable whose value is directly set by the agent’s internal decision function. Endogenous (non-decision) A variable whose value is determined within the model as a computational consequence of other variables or functions, but is not directly controlled by the agent’s decisions. Figure 2: Classification of agent variables in VISA. Variables are first distinguished by whether their values can be changed by internal functions (agent behaviors): Exogenous variables cannot, while Endogenous variables can. Each category is further divided into two subtypes. The Symbol column assigns a mathematical identifier using the notation conventions of Section 3.2; temporal dynamics are captured through subscripts (t, t−1t-1). The Data Type column specifies the variable’s data structure using programming-language notation (e.g., Integer, Float, Boolean, List[Integer]) to facilitate implementation. The Value column traces each variable’s provenance: exogenous variables are marked as “Input” (referencing Table 6), while endogenous variables reference the function ID (f1–f13) from Table 4 that computes them. For an agent type with a single instance (N=1N=1), the homogeneous/heterogeneous distinction is vacuous, so its exogenous variables may carry either label without affecting the specification; this is a notation convenience rather than a binding constraint. Table 2: VISA Table 2: Agent variables (multi-newsvendor example) Variable Symbol Type Data Type Value Unit Desc. Env. ℰE SensingNet count N_S Exog.-homo. Integer Input – Fixed agent count Wholesaler count N_W Exog.-homo. Integer Input – Fixed agent count Customer count N_C Exog.-homo. Integer Input – Fixed agent count Vendor count n,tn_V,t Endog. Integer f1, f2 – Current number of vendors Vendor list ℒ,tL_V,t Endog. List[Integer] f1, f2 – List of active vendor IDs Avg. retail price p¯t p_t Endog. Float f3 $/unit Mean price across vendors SensingNet S Connection probability ρ Exog.-homo. Float Input – Edge formation probability Initial adjacency matrix A(0)A^(0) Exog.-homo. Matrix[Integer] Input – Initial vendor network topology Current adjacency matrix AtA_t Endog. Matrix[Integer] f4 – Current vendor network topology Wholesaler W Wholesale price pwp_w Exog.-homo. Float Input $/unit Fixed wholesale cost Vendor V Pricing params Ma,MbM_a,M_b Exog.-homo. Float Input – Multiplier distribution bounds Pricing multiplier mim_i Exog.-hetero. Float Input – ∼U(Ma,Mb) U(M_a,M_b) Order quantity qi,tq_i,t Endog.-dec. Integer f8 units Ordering decision Retail price pi,tp_i,t Endog.-dec. Float f7 $/unit Pricing decision Local avg price p^i,t p_i,t Endog. Float f6 $/unit Avg of self & neighbor prices Current & prev. sales si,t,si,t−1s_i,t,s_i,t-1 Endog. Integer f13 units Period sales Sales history i,ts_i,t Endog. List[Integer] f5 – Historical sales vector Sales increase flag δi,t _i,t Endog. Boolean f11 – Boolean indicator Profit πi,t _i,t Endog. Float f9 $ Current-period profit Wealth wi,tw_i,t Endog. Float f10 $ Cumulative wealth Customer C Base demand D Exog.-homo. Integer Input units Total market demand Demand noise σ Exog.-homo. Float Input – Std. dev. of demand shock 3.3.3 Table 3: Sensing The Sensing table specifies the information access structure as a quasi-matrix: rows represent observer agents (active agents plus the environment), columns represent observed agents (all agent types), and each cell lists the variables that the row agent can read from the column agent (Table 3). The table is divided into two sections by a vertical line: active agents (Environment, Space, Decision-makers) appear to the left and can both observe and be observed, while passive agents appear to the right and can only be observed. The symbol ∗* denotes access to all attributes of the observed agent; ∅ denotes no access. On the diagonal, a cell states what an instance may observe of other instances of its own type (its peers): the list of accessible peer attributes, or ∅ if same-type agents observe nothing of one another. A single-instance type (N=1N=1) has no peers, so its diagonal is ∅ . (Every agent reads its own complete state by default, so self-observation is implicit and is not recorded in the matrix.) Space agents appear as columns—they mediate information access through topological structure (e.g., a vendor can read the adjacency matrix from the Space agent to identify its neighbors). Passive agents (e.g., the Wholesaler) also appear only as columns. By making this structure explicit, VISA ensures that the model’s rationality assumptions are unambiguous and that inter-agent information flows can be fully traced. Table 3: VISA Table 3: Agent sensing (multi-newsvendor example) Observer Observed (active) Observed (passive) ℰE (Env.) S (SensingNet) V (Vendor) C (Cust.) W (Whol.) ℰE (Env.) ∅ ∅ pi,πi,wip_i, _i,w_i ∅ ∅ S (SensingNet) ℒL_V ∅ wiw_i ∅ ∅ V (Vendor) ∅ AtA_t pjp_j ∅ pwp_w C (Cust.) ∅ ∅ pip_i ∅ ∅ Reading the matrix row by row (an agent’s own state is read by default and not shown): the environment observes each vendor’s price, profit, and wealth; SensingNet reads the vendor list and wealth (for preferential attachment) and maintains its own adjacency matrix; each vendor reads the adjacency matrix (to identify neighbors), its peer neighbors’ prices pjp_j on the diagonal, and the wholesale price, but not non-neighbors’ other attributes; the customer observes all vendor prices. Singleton types (environment, SensingNet, customer) have ∅ diagonals. 3.3.4 Table 4: Internal Function The Internal Function table specifies the behavioral logic and computational procedures of every agent (Table 4). Each function is assigned a unique ID (f1–f13) that is referenced by the Value column in Table 2. Beyond the ID, each function has three input–output specifications: Decision Basis (information used, from Tables 2–3); Self-state Update (the agent’s own endogenous variables modified); and External Effect (modifications to other agents’ variables). Ref. cites the literature motivating the Method, making each behavioral choice traceable (blank “—” for purely mechanical computations). A core VISA principle follows: every internal function exists to update endogenous variables—its own or another agent’s. Table 4: VISA Table 4: Internal functions (multi-newsvendor example) ID Function Method Decision Basis Self-state Update External Effect Ref. Environment ℰE f1 create_vendor Instantiation πi _i (all vi∈v_i ) n←n+1n_V← n_V+1 New viv_i [43] f2 remove_vendor Removal wiw_i (any viv_i: wi<0w_i<0) n←n−1n_V← n_V-1 Delete viv_i [43] f3 compute_avg_price Mean pip_i (all vi∈v_i ) p¯←1n∑pi p← 1n_VΣ p_i — — SensingNet S f4 create_adjacency Preferential attachment ℒ,wiL_V,\,w_i (all vi∈v_i ) At←A_t← preferential(wiw_i) — [7] Vendor V f5 update_history Append si,t−1s_i,t-1 i←i∪si,t−1s_i _i∪\s_i,t-1\ — — f6 compute_local_avg Mean pj(j∈i)p_j\,(j _i) p^i←1|i|+1(pi+∑j∈ipj) p_i← 1|N_i|+1(p_i+ _j _ip_j) — — f7 set_price Conditional p^i,δi,mi p_i,\, _i,\,m_i pi←p_i← Eq. (2) — — f8 decide_order Optimization i,pi,pws_i,\,p_i,\,p_w qi←q_i← Eq. (3) — [4] f9 compute_profit Arithmetic pi,pw,si,t,qip_i,\,p_w,\,s_i,t,\,q_i πi←pisi,t−pwqi _i← p_is_i,t-p_wq_i — — f10 update_wealth Addition πi _i wi←wi+πiw_i← w_i+ _i — — f11 update_sales_change Comparison si,t,si,t−1s_i,t,\,s_i,t-1 δi←(si,t>si,t−1) _i←(s_i,t>s_i,t-1) — — f12 record_sales Transfer si,ts_i,t si,t−1←si,ts_i,t-1← s_i,t — — Customer C f13 allocate_demand Multinomial logit pjp_j (all vj∈v_j ), D,σD,σ — si,ts_i,t via Eq. (4) [39] Three key functions warrant further detail. Local average price computation aggregates the vendor’s own price with its neighbors’ prices according to the network topology defined by the adjacency matrix: p^i=1|i|+1(pi+∑j∈ipj), p_i= 1|N_i|+1\! (p_i+ _j _ip_j ), (1) where i=j:Aij=1N_i=\j:A_ij=1\ denotes the neighbor set of vendor viv_i derived from the current adjacency matrix AtA_t. Vendor pricing then follows a simple adaptive rule: pi=p^i(1+mi)if δi=true(sales increased),p^i(1−mi)otherwise(sales decreased).p_i= cases p_i\,(1+m_i)&if _i=true (sales increased),\\ p_i\,(1-m_i)&otherwise (sales decreased). cases (2) Each vendor raises its price above the local average when its sales increase, and lowers it otherwise, with the heterogeneous multiplier mi∼U(Ma,Mb)m_i U(M_a,M_b) determining the magnitude of adjustment. Vendor ordering applies the classical newsvendor critical fractile [4]: qi=Fi−1(pi−pwpi),q_i=F_i^-1\! ( p_i-p_wp_i ), (3) where Fi−1F_i^-1 is the inverse CDF computed from vendor viv_i’s accumulated historical sales is_i. Customer demand allocation uses a multinomial logit model [39]: si,t=e−pi1+∑vj∈e−pj⋅D+ε,ε∼(0,σ2),s_i,t= e^-p_i1+ _v_j e^-p_j· D+ , (0,σ^2), (4) ensuring that vendors with higher prices receive less demand. 3.4 Model-Level Description 3.4.1 Table 5: Associated Data The Associated Data table (Table 5) documents all external data sources referenced by the model. Data provenance is a critical but often under-specified aspect of ABM documentation. Laatabi et al. [34], in the ODD+2D extension, identify several shortcomings in current practice: information about data sources, collection methods, preprocessing, and the mapping from data to model entities is typically scattered across the description or omitted entirely. They emphasize that a model description should make transparent: (i) where data comes from and how it was collected; (i) how raw data is selected, filtered, and transformed before entering the model; (i) which data attributes map to which model variables; and (iv) whether the data is sufficient for model calibration and validation. VISA’s Table 5 consolidates these requirements into a single structured table, capturing the complete data provenance chain: source, collection method, preprocessing steps, number of records, and availability. Several columns use predefined, controlled vocabularies to ensure unambiguous documentation. We formally define these options below. Type The origin category of the data source: • Empirical: Data obtained from direct real-world observations, measurements, surveys, or experiments—reflecting actual phenomena in the target system. • Literature: Parameter values or datasets sourced from published academic works (journal articles, books, technical reports) that have undergone peer review or editorial quality control. • Generated: Data produced by computational processes, including synthetic population generation, random sampling from specified distributions, or output from auxiliary simulation models. Temporal The time-varying nature of the data within the simulation: • Static: The data remains constant throughout the simulation run and is loaded once (typically at initialization). • Dynamic: The data is updated or reloaded at one or more time steps during the simulation, reflecting temporal changes in the external environment. Collection The method by which the data was originally obtained: • Survey: Data collected through structured questionnaires, interviews, or field surveys involving human or organizational respondents. • Administrative: Data obtained from institutional records, government databases, census data, or organizational information systems. • Sensor: Data collected automatically via sensors, monitoring devices, remote sensing, or other automated measurement instruments. • Experimental: Data produced through controlled experiments designed for the modeling project. • Computational: Data generated by algorithms, mathematical procedures, or auxiliary simulation models. Pre-processing The primary transformation applied to raw data before entering the model: • None: Raw data is used directly without any modification. • Selected: A subset of records or variables is extracted from a larger dataset based on specified criteria (e.g., date range, quality threshold, geographic area). • Aggregated: Multiple records are combined into summary statistics (e.g., mean, sum, distribution fitting) or coarser-grained categories, reducing the number of records. • Transformed: Data values are converted through mathematical operations, type casting, normalization, discretization, or mapping rules, without changing the number of records. Availability The access level of the data: • Open: The data is publicly accessible under an open license or no license restrictions. • Restricted: The data is available under specific conditions (e.g., license agreement, registration, institutional affiliation). • Private: The data is not publicly available due to privacy, confidentiality, or proprietary constraints. In the multi-newsvendor example, the model draws on regional dairy market records to parameterize vendor pricing and customer demand. Table 5: VISA Table 5: Associated data (multi-newsvendor example) ID Title Type Temporal Source Collection Pre-processing #Rec. Avail. d1 Milk vendor prices Empirical Static Source A, 2025 Administrative None 1,200 Open d2 Milk vendor sales Empirical Static Source A, 2025 Administrative None 1,200 Open 3.4.2 Table 6: Input and Output The Input and Output table bridges external data and simulation results through two sub-tables. The Input sub-table (Table 6a) specifies every exogenous parameter: its value or probability distribution, the data source (referencing Table 5), the derivation method, the algorithm used, and a reference grounding that algorithm. The Output sub-table (Table 6b) defines the simulation’s output indicators: computation formula, data type (following the vocabulary of Table 2), unit, sampling frequency, and description. Several columns of Table 6 use predefined values; we specify their meaning below. Derivation (Input sub-table) The method by which an exogenous parameter value is obtained from its data source: • Direct: The value is taken verbatim from the referenced data source (Table 5) without any further processing. • Estimated: The value—or the parameters of its probability distribution—is statistically inferred from the referenced data (e.g., fitting distribution parameters, estimating a mean or variance from a sample). • Computed: The value is produced by a deterministic or stochastic procedure applied to other known quantities (e.g., a formula, or a randomized construction such as the random-connect build of A(0)A^(0)), without statistical inference from data. • Assumed: The value is fixed by model design, expert judgment, convention, or the literature, and is not obtained from the referenced data. Algorithm (Input sub-table) When Derivation is Estimated or Computed, this column names the specific procedure applied—either a standard method (e.g., “maximum likelihood estimation”) or a model-specific construction (e.g., the random-connect build of A(0)A^(0)). As with the Method column of Table 4, the choice among alternative procedures is modeler-dependent; the adjacent Ref. column therefore cites the literature or formula that motivates each choice. Frequency (Output sub-table) The sampling interval of an output indicator, recorded as an integer counting the number of time steps between consecutive samples: • k≥1k≥ 1: the indicator is sampled once every k time steps—k=1k=1 records every step (a complete time series), while k>1k>1 downsamples. • −1-1: the indicator is recorded only once, at the final time step (the terminal state of the run), following Python’s convention that index −1-1 selects the last element. The Data Type column of the Output sub-table reuses the type vocabulary of Table 2 (e.g., Integer, Float, List[Integer], Matrix[Integer]) and is therefore not redefined here. In the multi-newsvendor example, the input parameters comprise author-specified structural constants (agent counts and network settings), pricing and wholesale parameters drawn from data record d1, and demand parameters from d2 (Table 5); the initial vendor network is constructed by the random-connect procedure (an Erdős–Rényi graph with probability ρ); and the three output indicators span the Float and List[Integer] data types, recorded at frequency 11 (every step) for the two scalar means and −1-1 (terminal step only) for the degree sequence. Table 6: VISA Table 6: Input and Output (multi-newsvendor example) (a) Input Symbol Value / Distribution Data source Derivation Algorithm Ref. Environment ℰE N,N,N_S,N_W,N_C 1, 1, 1 Author Assumed — — SensingNet S ρ 0.3 Author Assumed — — A(0)A^(0) Random adjacency Author Computed Erdős–Rényi (ρ) [16] Wholesaler W pwp_w 100 d1 Direct — — Vendor V Ma,MbM_a,M_b 0.1, 0.5 d1 Estimated Empirical range — mim_i U(Ma,Mb)U(M_a,M_b) d1 Computed Uniform sampling — Customer C D 10000 d2 Estimated Mean — σ 500 d2 Estimated Std. dev. — (b) Output Symbol Indicator Formula Data Type Unit Frequency Desc. π¯ π Avg. profit 1n∑vi∈πi 1n_V _v_i _i Float $ 11 Mean vendor profit S¯r Sr Avg. service level 1n∑isi,t/qi 1n_V _is_i,t/q_i Float — 11 Fill rate across vendors d Degree distribution degree(At)degree(A_t) List[Integer] – −1-1 Network degree sequence The initial adjacency matrix A(0)A^(0) of the SensingNet space is a symmetric Erdős–Rényi random graph: each off-diagonal entry Aij(0)=Aji(0)A^(0)_ij=A^(0)_ji is set to 11 independently with probability ρ∈(0,1)ρ∈(0,1) and to 0 otherwise [16]. 3.4.3 Table 7: Schedule The Schedule table defines the temporal execution sequence of the simulation (Table 7). The execution schedule (Table 7a) lists the per-step loop: each step identifies the acting agent, the function (by its ID and name, referencing Table 4), and the execution mode. Initial values are not part of this loop; they are supplied as exogenous inputs via Table 6. The execution mode specifies how the agent instances of a function are scheduled within a step—a crucial but often under-documented aspect of ABM [6]—and is orthogonal to the trigger, which is recorded in the Condition column. We define its values below. Synchronous All agent instances observe the state at the start of the step and apply their updates simultaneously; no instance sees another’s within-step update (lockstep, parallel update). Sequential Instances act one at a time in a fixed, deterministic order; each instance observes the updates of those earlier in the order (serial update with first-mover effects). Random-order As Sequential, but the order is uniformly randomized and reshuffled each step, eliminating systematic ordering bias. Asynchronous Instances are not synchronized to the global step; each activates at independently drawn times or in response to events (event-driven scheduling). Where a mode admits mode-specific parameters, they are appended in parentheses after the mode name—for instance, Sequential (by wiw_i, descending) records that instances act in descending order of wealth, and Asynchronous (Poisson, λ) records the activation rate—so the schedule remains fully specified without a separate parameter column. Two further scheduling notions are deliberately not treated as base modes: conditional activation (a function firing only when a trigger holds) is recorded in the Condition column rather than as an execution mode; and staged execution—a step decomposed into synchronized sub-phases such as sense → decide → update, in which all agents complete one phase before any begins the next—is a composite pattern built from the four modes above. Staging is useful when within-step information contamination must be ruled out (every decision then rests on the same start-of-step snapshot), though it is a local organizing principle rather than a fixed global structure, since a complex model may run several sense–decide–update rounds within a single step for distinct subsystems (e.g., reputation or regulation). Different execution modes can produce qualitatively different outcomes even with identical behavioral rules—a fact long recognized in work on synchronization in parallel agent-based simulation [67]—making this specification essential for reproducibility. The schedule also specifies termination conditions (Table 7b) as a logical combination of indicator-based criteria referencing Table 6. Table 7: VISA Table 7: Schedule (multi-newsvendor example) (a) Execution schedule Step Agent ID Function Exec. mode Condition 1 ℰE f1 create_vendor Synchronous Every step; only if all πi>0 _i>0 2 S f4 create_adjacency Synchronous Only when a new vendor is added 3 V f5 update_history Synchronous Every step 4 V f6 compute_local_avg Synchronous Every step 5 ℰE f3 compute_avg_price Sequential (by vendor ID) Every step 6 V f7 set_price Synchronous Every step 7 V f8 decide_order Synchronous Every step 8 C f13 allocate_demand Sequential (by vendor ID) Every step 9 V f9 compute_profit Synchronous Every step 10 V f10 update_wealth Synchronous Every step 11 V f11 update_sales_change Synchronous Every step 12 V f12 record_sales Synchronous Every step 13 ℰE f2 remove_vendor Synchronous Every step; only if any wi<0w_i<0 (b) Termination conditions ID Indicator Condition Description Value Source/Ref Termination logic c1 t t≥1000t≥ 1000 Max. time steps reached Author Assumed Stop when c1∨c2c1 c2 c2 π¯ π |π¯(t)−π¯(t−1)|<0.01| π^(t)- π^(t-1)|<0.01 Avg. profit stable Author Assumed 3.4.4 Table 8: Validation The Validation table establishes the model’s credibility assessment framework (Table 8). It instantiates the Hierarchical ABM Validation (HAV) framework of He et al. [27] which organizes validation across three levels aligned with the agent-based modeling process and distinguishes data-grounded from non-data-grounded methods. Each entry carries a stable ID (v1, v2, …) so that readers can cite individual validation criteria, and is grouped into one of three levels mirroring the HAV hierarchy: Agent (individual behavior), Model (structural mechanisms), or Output (aggregate results). The benchmark data, method, indicator, and passing condition together define an unambiguous, testable criterion; the Ref column points to prior work that employs the same validation method. Modelers are encouraged to add further entries—for example, additional agents, mechanisms, or output indicators—to achieve a more comprehensive validation. Table 8: VISA Table 8: Validation (multi-newsvendor example) ID Validation object Benchmark data Method Indicator Passing cond. Ref Agent level v1 Individual vendor sales d2 (milk vendor sales) K-S test (two-sample) p-value p>0.05p>0.05 [27] Model level v2 Price correlation across SensingNet Positive autocorrelation expected Moran’s I (network) Moran’s I I>0I>0, p<0.05p<0.05 — Output level v3 Avg. profit vs. vendor count Profit decreases with n_V Regression π¯∼n π n_V slope β β<0β<0, p<0.05p<0.05 — 4 Operationalization: Consistency Rules and Skills Beyond the eight-table format of Section 3, VISA contributes two artifacts that make the format practical at scale: a set of consistency rules that turn model validity into a checkable property, and three skills that automate authoring, checking, and code generation. 4.1 Consistency Rules The eight VISA tables are interrelated and governed by 19 consistency rules that ensure model completeness and logical validity (Tables 9 and 10). They fall into two categories: within-table rules (r1–r4), which govern consistency within a single table, and cross-table rules (r5–r19), which link entries across different tables; when all are satisfied, the specification is guaranteed complete, consistent, and reproducible. In the Tables column, Tkk denotes Table k of the VISA protocol (T7b denotes the termination sub-table of T7); an arrow (→) indicates a directional dependency from source to target, a double arrow (↔ ) marks a bidirectional rule that is checked in both directions, and a within-table rule lists a single table. Table 9: VISA within-table consistency rules (r1–r4). ID Tables Rule r1 T2 Variable-type coverage and time-indexing. T2 must classify every variable with one of the four leaf types—Exog.-homo., Exog.-hetero., Endog.-dec., or Endog. (non-decision); a bare exogenous/endogenous label or a blank Type leaves provenance ambiguous. In addition, every endogenous variable must carry the time index t in its symbol (e.g., xi,tx_i,t, si,ts_i,t), reflecting that it evolves over the simulation, whereas exogenous variables do not. r2 T4 Function-ID uniqueness. Every function in T4 must carry a unique f-ID. r3 T4 Function productivity. Every function in T4 must modify at least one endogenous variable, listed in its Self-state Update or External Effect; a function that reads inputs but writes nothing is incomplete. r4 T7 Step–Exec. mode consistency. Within the execution schedule of T7, all functions assigned the same Step number must share the same Exec. mode, since a Step schedules functions that execute together; conversely, functions that must execute simultaneously are assigned a common Step. Table 10: VISA cross-table consistency rules (r5–r19). An arrow (→) indicates a directional dependency from source to target; a double arrow (↔ ) marks a bidirectional rule checked in both directions. ID Tables Rule r5 T1 → T3 Same-type (peer) sensing. Every agent type with variable quantity n>1n>1 must record on the T3 diagonal the attributes its instances observe of one another (the peer set; ∅ if they observe nothing of each other); single-instance types (N=1N=1) have no peers and their diagonal is ∅ . (Self-observation is implicit and not recorded.) r6 T1 → T2, T3, T4 Passive-agent implications. Agents categorized as Passive in T1: (i) have no endogenous variables in T2; (i) appear only as columns in T3 (right of the vertical line); (i) have no internal functions in T4. r7 T1 → T3 Observer-row completeness. Every non-passive agent type in T1 must have exactly one row in T3; passive agents have no rows. r8 T1 → T2, T4 Population-dynamics consistency. An agent type whose T1 Quantity is variable (n) must be created or removed by at least one T4 function; a type with a fixed Quantity (N) must not. r9 T1 → T4 Active-agent function coverage. Every active (i.e., non-Passive) agent type in T1 must own at least one internal function in T4, and is therefore represented in the execution schedule of T7. r10 T2 → T3 Variable observability. Every variable in T2 must be specified as observable in at least one cell of T3 (except variables never accessed by any function). r11 T2 → T4 Endogenous-variable completeness. Every endogenous variable in T2 must be updated by at least one T4 function whose f-ID is listed in the Value column and exists in T4; a variable may be updated by multiple functions across a step. Orphaned variables or dangling f-IDs indicate incomplete specification. r12 T2 → T4 Self-state-update validity. All variables in the Self-state Update column of T4 must be endogenous variables of that agent (as defined in T2). Exogenous variables cannot appear in Self-state Update. r13 T2 → T4 External-effect validity. Each entry in the External Effect column of T4 is either (i) an endogenous variable of another agent (per T2), or (i) the creation or removal of an instance of a variable-quantity type (governed by r8). Modifying another agent’s exogenous variables is forbidden. r14 T3 → T4 Information-access validation. For every function in T4, all variables in the Decision Basis column must be either: (i) an attribute of the agent itself; or (i) a variable from T3 that the agent is authorized to observe. r15 T6 ↔ T2 Input–output coverage. Every Input symbol in T6a must correspond to an exogenous variable in T2, and every T2 variable marked “Input” must have a T6a entry; every Output indicator in T6b must be computable from variables in T2. r16 T7 ↔ T4 Schedule coverage. Every function in T4 must appear at least once in the Execution schedule of T7, and every function ID in T7a must exist in T4; a function may be scheduled multiple times within a step, but none may be left unscheduled or phantom. r17 T7b → T2, T6 Termination-indicator source. Every indicator referenced in the termination conditions of T7b must be either a variable of T2 or an output indicator of T6 (the global time index t is always available and need not be declared). r18 T8 → T2, T6 Validation-object coverage. Every quantity submitted to validation in T8 (the Validation object) must be expressed in terms of T2 variables or T6b output indicators; the test statistic in the Indicator column is computed during validation and is not itself a model variable. r19 T8, T6a → T5 Data-reference resolution. Every empirical data reference in T8 (Benchmark data) and in T6a (Data source) must resolve to a T5 record (d-ID); references marked “Author” and purely theoretical benchmarks are exempt. These 19 rules serve two audiences at once: a modeler runs them as a self-check before release, and an evaluator (reviewers, program officers, stakeholders) uses them as a review checklist. Because VISA distributes a model’s assumptions across the tables—scale and persistence in T1, provenance in T2, information flow in T3, behavior in T4, data in T5, parameters in T6, timing in T7, and validation in T8—each assumption is locatable and contestable rather than buried in narrative; parameters whose Derivation is Assumed (T6a) and the thresholds of T7b surface the model’s subjective choices directly, and T8 functions as a contract an evaluator may extend with further tests. 4.2 Skills Manually maintaining eight interrelated tables is tedious and error-prone—itself a source of the reproducibility failures VISA aims to eliminate. We therefore provide three reusable skills—self-contained instruction sets that an LLM agent executes—that operationalize the protocol: an authoring, a checking, and a code-generation skill, released as supplementary material and on GitHub (https://github.com/AgentLabCn/visa). The authoring skill constructs the eight tables in canonical pipeline order (T1–T8), since each table supplies identifiers that later tables reference—agent types from T1 anchor T2’s variables, and function IDs from T4 populate T2’s Value column—while enforcing the controlled vocabularies and notation of Section 3 so the tables are immediately machine-parseable. The checking skill verifies all 19 rules (Tables 9 and 10) automatically, reporting each rule’s pass/fail status, the implicated cells, and a concrete fix—turning the rules into an executable validator. The code-generation skill turns a verified specification into runnable code: for each agent it emits the state variables (Table 2), functions (Table 4) as methods, the sensing neighborhood (Table 3), and the data and parameter wiring (Tables 5–6); the schedule (Table 7a) becomes the step loop and the validation entries (Table 8) become executable checks. The three skills form one loop—author the tables, run the checker until all 19 rules pass, generate code, and re-run the validation—at which point the specification is complete, consistent, and reproduced. 5 Empirical Evaluation To test the protocol’s central claim—that a VISA specification is sufficient to reproduce a model—we applied the full author–check–code loop to three external, independently authored agent-based models that the present authors did not write. Targeting models we have no stake in defeats the obvious objection that a description protocol can be made to look good on a model designed for it. Table 11 summarizes the outcome; the complete eight-table specifications, the 19-rule reports, and the full reproduction results are in the supplementary material, and all runnable code is on GitHub (https://github.com/AgentLabCn/visa). Table 11: The VISA loop applied to three external ABMs. author/check/code are the three skills; “reproduce” re-executes the T8 validation. Models 1–2 are reproduced cross-language (NetLogo → Python); Model 3 is a describe-only expressiveness case. Model Platform author check code reproduce Outcome Rebellion [14] NetLogo→ ✓ 19/19 ✓ ✓ v1–v3 pass Wolf Sheep Stride [45] NetLogo→ ✓ 19/19 ✓ ✓ v2–v5 pass; v1 dir. AgedCareContactModel AnyLogic ✓ 19/19 — — blocked Setup. The two primary models are NetLogo library models; we re-implemented each in Python directly from its VISA specification, making the reproduction cross-language (NetLogo → Python), a stronger test than re-implementing in the same language. The reproduction target is each model’s qualitative signature—a pattern that is structurally determined and not sensitive to the random seed—rather than a bit-exact trajectory. Both pass all 19 consistency rules, generate runnable Python, and reproduce their signature dynamics. The third is an industrial AnyLogic model used as an expressiveness test and an honest limit case. Rebellion. The civil-violence model of Epstein [14] reproduces its punctuated-equilibrium signature: the active-citizen count shows periodic rebellion episodes (peaks near 300, roughly 30 per 1000 ticks) separated by long quiescent stretches. Figure 3 overlays the NetLogo 6.4 reference against the Python re-implementation generated from the specification; the two reproduce the same qualitative pattern. T8 criteria v1–v3 pass. Figure 3: Rebellion reproduction—active-citizen count over time. The NetLogo 6.4 reference (3 runs) and the Python re-implementation from the VISA specification (3 seeds) are min–max bands with solid means. The punctuated-equilibrium signature is reproduced cross-language; the pattern is robust to the random seed. Wolf Sheep Stride Inheritance. This model carries an inheritable, mutating stride-length trait—the distance an animal moves per step, passed to offspring with random mutation—so natural selection on movement distance can be observed, and the population’s mean stride length is the model’s headline selection indicator. Its headline result concerns the stride-length energy penalty, a switch that, when on, charges each animal energy equal to its stride length per step (moving farther costs more); when off, movement is free. The penalty causally reverses the direction of wolf-stride selection: with the penalty on, the cost of moving far outweighs the extra prey caught, so wolves evolve a shorter stride (1.0→ 0.78); with it off, moving far is free and catches more sheep, so they evolve a longer one (1.0→ 1.18). Figure 4 overlays the NetLogo 6.4 reference against the VISA-driven Python reproduction, showing that both platforms reproduce the reversal. Parameter-dependent extinction and predator–prey oscillation also reproduce (full overlay figures in the supplementary). T8 v2–v5 pass; v1 (sheep stride converging toward 1) is reproduced only directionally, a shortfall we attribute to the model’s grass-abundance structure rather than to any specification error. Figure 4: Wolf stride-length selection (default model). The NetLogo 6.4 reference (solid) and the Python re-implementation generated from the VISA specification (dashed)—each a mean over 3 runs/seeds—both reproduce the causal reversal: penalty on → shorter stride; off → longer. AgedCareContactModel. This AnyLogic 8.9 model of an aged-care facility produces epidemiological contact matrices, and it exercises VISA’s expressiveness on a real, industrially authored model: visa-author captures its 29 object types and 240 functions in eight tables (consolidated to 4 agent sets and 14 behavioural functions), and visa-check passes 19/19 with no structural accommodation. Full reproduction is blocked, and this is itself a finding rather than a VISA failure. The model’s behavior splits into (a) reproducible custom Java logic, fully captured in the tables, and (b) movement executed by AnyLogic’s proprietary Pedestrian Library, which dominates the contact-matrix output and has no open specification. VISA makes (a) explicit and exposes (b) as a named, localized dependency—the real barrier—rather than letting it hide in prose; the unavailable backing data is a second, independent blocker. No reproduction figure is shown for this case, by design. Across the three models, VISA scales from a textbook NetLogo model to an industrial AnyLogic model, reproduces the two whose behavior is entirely in open code, and honestly demarcates its limit on the one that depends on a proprietary library. The reproduction barrier moves from the model—where it is invisible—to a named dependency, where it is actionable. 6 Discussion We discuss two aspects of VISA that bear on its broader adoption: its relationship to visual model documentation, and its applicability to agents whose behavior is learned rather than analytically specified. 6.1 Visualization and Human Readability VISA and visualization are complementary, not competing: the table-based specification is in fact a stronger substrate for producing diagrams than narrative prose. Several tables correspond directly to established diagram types—the sensing matrix (Table 3) is a directed graph, the agent–function ownership of Tables 1 and 4 maps onto a UML class diagram, and the schedule (Table 7) onto a sequence diagram—and because every table is structured and symbol-based, these visuals can be generated automatically from the specification, whereas rendering an ODD narrative requires manual translation. VISA thus provides the machine-interpretable source from which visual layers such as Visual ODD [59, 35] and UML [9] render the human-readable view; the two are designed to be used together. 6.2 Complex Agent Behaviors: Reinforcement Learning and LLM-Based Agents VISA can also accommodate agents governed by a reinforcement-learning (RL) policy or a large language model (LLM), without structural change, because it specifies behavior at the level of a function’s input–output contract rather than its internal mechanism. Both fit Table 4 directly: the Decision Basis is the observed state or the variables serialized into a prompt; the Self-state Update is the chosen action or parsed decision; the Method names the learned policy or language model. The nineteen consistency rules are mechanism-agnostic, governing structural completeness rather than behavioral form, so an RL- or LLM-driven model satisfies exactly the same rules as the multi-newsvendor. The genuine difficulty is reproducibility, not specification. A learned component is defined by its training configuration—algorithm, hyperparameters, data, and seed for RL; exact model version, prompt, decoding parameters, and seed for an LLM—all of which VISA can capture (data in Table 5, parameters and seeds in Table 6, the model in the Ref column). Even so, LLM-based agents carry a residual reproducibility hazard that no description protocol can fully eliminate: model versions drift and inference is stochastic. As with the proprietary-library dependency of Section 5, VISA’s contribution is to make the configuration explicit and to localize the irreproducibility to a named, versioned component rather than letting it hide in prose; bounding it remains an open problem. 7 Conclusion Agent-based modeling has become an indispensable methodology for complex systems, yet its scientific credibility rests on a reproducibility that the field has struggled to deliver. The root difficulty is descriptive: existing protocols are predominantly text-centric, not machine-readable, and leave a wide gap between a model’s documentation and its executable implementation. We have argued that the way forward is to first ask what information is truly indispensable for reproducing an agent-based model, and then to fix that information in a structured, symbol-based form. This paper proposed VISA, a table-based description protocol that answers that question. VISA organizes a model’s complete specification into eight interconnected tables across two levels—four at the agent level (Agent, Variable, Sensing, Internal Function) and four at the model level (Associated Data, Input/Output, Schedule, Validation)—under the principle of minimality with completeness: every element is indispensable, and together they are necessary and sufficient for a model to be unambiguously understood, faithfully reproduced, critically evaluated, and productively extended. Symbol-based notation removes the ambiguity of natural language, explicit cross-references make every dependency traceable, and nineteen consistency rules turn model validity from a matter of judgment into a checkable property, as illustrated throughout by the multi-newsvendor example. To move the protocol from specification to practice, we operationalized it with two artifacts: nineteen executable consistency rules and three reusable skills (authoring, checking, code generation). Together they target the three properties the field most lacks—transparency, through explicit and locatable tables; reproducibility, through automated code generation and pinned execution modes; and verifiability, through executable rules and an extensible validation table. Empirically, the full author–check–code loop closes on three external, independently authored models: the Rebellion and Wolf Sheep Stride Inheritance models are reproduced cross-language (NetLogo to Python) directly from their VISA specifications, each passing all nineteen rules and recovering its qualitative signature, while a large industrial AnyLogic model is captured faithfully in eight tables (again 19/19), with its reproduction barrier—a proprietary movement library and unavailable backing data—made explicit rather than hidden. The protocol has clear limits, and each points to a direction for improvement. VISA complements rather than replaces visual documentation, so a natural next step is visualization tools that render its tables automatically, bridging to the visual standards modelers already use. Its benefits over narrative description still await quantitative evidence: a systematic comparison with the ODD family would measure the trade-off in information coverage and documentation burden, and a controlled reproduction study—independent teams re-implementing the same model from a VISA specification and from a narrative description—would quantify the effect on faithful replication. VISA accommodates reinforcement-learning and LLM-based agents without structural change, yet the residual hazard of versioned, stochastic black-box components is one no description protocol can fully eliminate; extending the skills to further platforms, and sharpening how such components are specified, would both broaden the protocol’s reach and refine this honest limit. Throughout, the aim is constant: to move agent-based models from implicit description toward specification that is explicit, locatable, and executable, bringing simulation-based research closer to the reproducibility standards expected of experimental science. Acknowledgments This work was supported in part by the National Natural Science Foundation of China (grant number 72271227), the Fundamental Research Funds for the Central Universities (grant numbers E1E40810X2), the Youth Innovation Promotion Association CAS (grant number 110800EAG2), and the MOE Social Science Laboratory of Digital Economic Forecasts and Policy Simulation at UCAS. References [1] S. Abar, G. K. Theodoropoulos, P. Lemarinier, and G. M. P. O’Hare (2017) Agent based modelling and simulation tools: a review of the state-of-art software. Computer Science Review 24, p. 13–33. External Links: Document Cited by: §2.1. [2] C. Alessandro, G. Antoine, C. Eugenio, G. Mauro, K. Stephen, and S. Joseph E. (2016-08) Agent based-stock flow consistent macroeconomics: towards a benchmark model. Journal of Economic Dynamics and Control 69, p. 375–408. External Links: Document Cited by: §1. [3] S. D. Angus and B. Hassani-Mahmooei (2015) ‘Anarchy’ reigns: a quantitative analysis of agent-based modelling publication practices in JASSS, 2001–2012. Journal of Artificial Societies and Social Simulation 18 (4), p. 16. External Links: Document Cited by: §2.1. [4] K. J. Arrow, T. Harris, and J. Marschak (1951) Optimal inventory policy. Econometrica 19 (3), p. 250–272. External Links: Document Cited by: §3.3.4, Table 4. [5] J. Augusiak, P. J. Van den Brink, and V. Grimm (2014) Merging validation and evaluation of ecological models to ‘evaludation’: a review of terminology and a practical approach. Ecological Modelling 280, p. 117–128. External Links: Document Cited by: §2.2.2. [6] R. Axtell, R. Axelrod, J. M. Epstein, and M. D. Cohen (1996) Aligning simulation models: a case study and results. Computational and Mathematical Organization Theory 1 (2), p. 123–141. External Links: Document Cited by: §1, §2.1, §3.4.3. [7] A. Barabási and R. Albert (1999) Emergence of scaling in random networks. Science 286 (5439), p. 509–512. External Links: Document Cited by: Table 4. [8] M. Batty (2007) Cities and complexity: understanding cities with cellular automata, agent-based models, and fractals. The MIT Press, Cambridge, Massachusetts. Cited by: §1. [9] H. Bersini (2012) UML for ABM. Journal of Artificial Societies and Social Simulation 15 (1), p. 9. Cited by: §1, §2.2.1, §6.1. [10] S. Bonzelet (2022-09) How increasing relative risk aversion affects retailer orders under coordinating contracts. International Journal of Production Economics 251, p. 108500. External Links: Document Cited by: §1. [11] A. J. Daly, L. De Visscher, J. M. Baetens, and B. De Baets (2022) Quo vadis, agent-based modelling tools?. Environmental Modelling & Software 157, p. 105514. External Links: Document Cited by: §1, §2.1. [12] E. Donkin, P. Dennis, A. Ustalakov, J. Warren, and A. Clare (2017) Replicating complex agent based models, a formidable task. Environmental Modelling & Software 92, p. 142–151. External Links: Document Cited by: §1, §2.1. [13] B. Edmonds and D. Hales (2003) Replication, replication and replication: some hard lessons from model alignment. Journal of Artificial Societies and Social Simulation 6 (4), p. 11. Cited by: §1, §2.1. [14] J. M. Epstein (2002) Modeling civil violence: an agent-based computational approach. Proceedings of the National Academy of Sciences 99 (Suppl. 3), p. 7243–7250. External Links: Document Cited by: Table 15, Table 15, Table 21, §5, Table 11. [15] J. M. Epstein (2009) Modelling to contain pandemics. Nature 460 (7256), p. 687–687. External Links: Document Cited by: §1. [16] P. Erdős and A. Rényi (1959) On random graphs i. Publicationes Mathematicae Debrecen 6, p. 290–297. Cited by: §3.4.2, Table 6. [17] D. Fanelli (2018) Opinion: is science really facing a reproducibility crisis, and do we need it to?. Proceedings of the National Academy of Sciences 115 (11), p. 2628–2631. External Links: Document Cited by: §1, §2.1. [18] T. Filatova (2015) Empirical agent-based land market: integrating adaptive economic behavior in urban land-use models. Computers, Environment and Urban Systems 54, p. 397–413. External Links: Document Cited by: §1. [19] D. Giovanni, F. Giorgio, and R. Andrea (2006-05) An evolutionary model of endogenous business cycles. Computational Economics 27 (1), p. 3–34. External Links: Document Cited by: §1. [20] V. Grimm, J. Augusiak, A. Focks, B. M. Frank, F. Gabsi, A. S. A. Johnston, C. Liu, B. T. Martin, M. Meli, V. Radchuk, P. Thorbek, and S. F. Railsback (2014) Towards better modelling and decision support: documenting model development, testing, and analysis using TRACE. Ecological Modelling 280, p. 129–139. External Links: Document Cited by: §1, §2.2.2. [21] V. Grimm, U. Berger, F. Bastiansen, S. Eliassen, V. Ginot, J. Giske, J. Goss-Custard, T. Grand, S. K. Heinz, G. Huse, A. Huth, J. U. Jepsen, C. Jørgensen, W. M. Mooij, B. Müller, G. Pe’er, C. Piou, S. F. Railsback, A. M. Robbins, M. M. Robbins, E. Rossmanith, N. Rüger, E. Strand, S. Souissi, R. A. Stillman, R. Vabø, U. Visser, and D. L. DeAngelis (2006) A standard protocol for describing individual-based and agent-based models. Ecological Modelling 198 (1-2), p. 115–126. External Links: Document Cited by: §1, §2.2.1. [22] V. Grimm, U. Berger, D. L. DeAngelis, J. G. Polhill, J. Giske, and S. F. Railsback (2010) The ODD protocol: a review and first update. Ecological Modelling 221 (23), p. 2760–2768. External Links: Document Cited by: §1, §2.2.1. [23] V. Grimm, S. F. Railsback, C. E. Vincenot, U. Berger, C. Gallagher, D. L. DeAngelis, B. Edmonds, J. Ge, J. Giske, J. Groeneveld, A. S. A. Johnston, A. Milles, J. Nabe-Nielsen, J. G. Polhill, V. Radchuk, M. Rohwäder, R. A. Stillman, J. C. Thiele, and D. Ayllón (2020) The ODD protocol for describing agent-based and other simulation models: a second update to improve clarity, replication, and structural realism. Journal of Artificial Societies and Social Simulation 23 (2), p. 7. External Links: Document, Link Cited by: §1, §1, §2.2.1, §2.2.1, §3.2. [24] V. Grimm, E. Revilla, U. Berger, F. Jeltsch, W. M. Mooij, S. F. Railsback, H. Thulke, J. Weiner, T. Wiegand, and D. L. DeAngelis (2005) Pattern-oriented modeling of agent-based complex systems: lessons from ecology. Science 310 (5750), p. 987–991. External Links: Document Cited by: §1. [25] J. Groeneveld, A. Klabunde, M. L. O’Brien, and A. Grow (2017) How to describe agent-based models in population studies?. Agent-Based Modelling in Population Studies, p. 237–254. Cited by: §2.2.2. [26] P. Guan, J. Zhang, V. M. Payyappalli, and J. Zhuang (2018-06) Modeling and validating public–private partnerships in disaster management. Decision Analysis 15 (2), p. 55–71. External Links: Document Cited by: §1. [27] Z. He, Q. Song, J. Lian, and Y. Liu (2026) Towards standardizing validation practices in agent-based modeling: a hierarchical abm validation framework. ACM Transactions on Modeling and Computer Simulation 36 (1), p. 1–25. External Links: Document Cited by: §3.4.4, Table 8. [28] D. Helbing, P. Molnár, I. J. Farkas, and K. Bolay (2001) Self-organizing pedestrian movement. Environment and Planning B: Planning and Design 28 (3), p. 361–383. Cited by: §C.1.10, §C.1, Table 37, Table 37. [29] E. Innocenti, C. Detotto, C. Idda, D. C. Parker, and D. Prunetti (2020) An iterative process to construct an interdisciplinary ABM using MR POTATOHEAD: an application to housing market models in touristic areas. Ecological Complexity 44, p. 100882. External Links: Document Cited by: §2.2.2. [30] M. A. Janssen, L. N. Alessa, M. Barton, S. Bergin, and A. Lee (2008) Towards a community framework for agent-based modelling. Journal of Artificial Societies and Social Simulation 11 (2), p. 6. Cited by: §2.2.3. [31] M. A. Janssen (2017) The practice of archiving model code of agent-based models. Journal of Artificial Societies and Social Simulation 20 (1), p. 2. External Links: Document Cited by: §1, §2.2.3. [32] V. Kazieva (2026) Towards model reproducibility: insights from replicating an agent-based model. In Proceedings of the 2026 Winter Simulation Conference, V. Ramamohan, A. Djanatliev, M. Fakhimi, C. Krejci, C. Ruiz Martin, B. S. Onggo, and N. Mustafee (Eds.), Cited by: §1, §2.3. [33] D. E. Knuth (1984) Literate programming. The Computer Journal 27 (2), p. 97–111. External Links: Document Cited by: §2.3. [34] A. Laatabi, N. Marilleau, T. Nguyen-Huu, H. Hbid, and M. A. Babram (2018) ODD+2D: an ODD based protocol for mapping data to empirical ABMs. Journal of Artificial Societies and Social Simulation 21 (2), p. 9. External Links: Document, Link Cited by: §1, §2.2.1, §3.4.1. [35] H. M. Lee and S. Lazarova-Molnar (2026) vODD-D: a visual documentation protocol for transparent and reproducible data-driven agent-based models. In Proceedings of the 2026 Winter Simulation Conference, V. Ramamohan, A. Djanatliev, M. Fakhimi, C. Krejci, C. Ruiz Martin, B. S. Onggo, and N. Mustafee (Eds.), Cited by: §1, §2.2.1, §6.1. [36] X. Li, W. Cai, and S. J. Turner (2017) Cloning agent-based simulation. ACM Transactions on Modeling and Computer Simulation 27 (2), p. 15:1–15:24. External Links: Document Cited by: §2.1. [37] C. Macal and M. North (2014) Introductory tutorial: agent-based modeling and simulation. In 2014 Winter Simulation Conference (WSC), p. 6–20. External Links: Document Cited by: §1, §2.1. [38] I. Mahmood, H. Arabnejad, D. Suleimenova, I. Sassoon, A. Marshan, A. Serrano-Rico, P. Louvieris, A. Anagnostou, S. J. E. Taylor, D. Bell, and D. Groen (2020-08) FACS: a geospatial agent-based simulator for analysing COVID-19 spread and public health measures on local regions. Journal of Simulation 16 (4), p. 355–373. External Links: Document Cited by: §1. [39] D. McFadden (1974) Conditional logit analysis of qualitative choice behavior. In Frontiers in Econometrics, P. Zarembka (Ed.), p. 105–142. Cited by: §3.3.4, Table 4. [40] T. Monks, C. S. M. Currie, B. S. Onggo, S. Robinson, M. Kunc, and S. J. E. Taylor (2019) Strengthening the reporting of empirical simulation studies: introducing the STRESS guidelines. Journal of Simulation 13 (1), p. 55–67. External Links: Document Cited by: §1, §2.2.2. [41] B. Müller, S. Balbi, C. M. Buchmann, L. De Sousa, G. Dressler, J. Groeneveld, C. J. Klassert, Q. B. Le, J. D. Millington, H. Nolzen, et al. (2014) Standardised and transparent model descriptions for agent-based models: current status and prospects. Environmental Modelling & Software 55, p. 156–163. External Links: Document Cited by: §1, §2.1, §2.2.1, §2.2.1, §2.3. [42] B. Müller, F. Bohn, G. Dreßler, J. Groeneveld, C. Klassert, R. Martin, M. Schlüter, J. Schulze, H. Weise, and N. Schwarz (2013) Describing human decisions in agent-based models – ODD + D, an extension of the ODD protocol. Environmental Modelling & Software 48, p. 37–48. External Links: Document Cited by: §1, §2.2.1. [43] R. R. Nelson and S. G. Winter (1982) An evolutionary theory of economic change. Belknap Press of Harvard University Press, Cambridge, MA. Cited by: Table 4, Table 4. [44] M. J. North and C. M. Macal (2007) Managing business complexity: discovering strategic solutions with agent-based modeling and simulation. Oxford University Press, New York. Cited by: §1, §1, §2.1. [45] M. Novak and U. Wilensky (2006) NetLogo Wolf Sheep Stride Inheritance model. Note: Center for Connected Learning and Computer-Based Modeling, Northwestern University, Evanston, ILNetLogo 6.x; C BY-NC-SA 3.0 Cited by: Table 26, Table 26, Table 26, Table 32, Table 32, Table 32, Table 11. [46] Open Science Collaboration (2015) Estimating the reproducibility of psychological science. Science 349 (6251), p. aac4716. External Links: Document Cited by: §1, §2.1. [47] D. C. Parker, D. G. Brown, J. G. Polhill, P. J. Deadman, and S. M. Manson (2006) Illustrating a new ‘conceptual design pattern’ for agent-based models of land use via five case studies—the MR POTATOHEAD framework. In Agent-Based Modelling in Natural Resource Management, A. López Paredes and C. Hernández Iglesias (Eds.), Cited by: §1, §2.2.2. [48] D. C. Parker, D. Brown, J. G. Polhill, S. Manson, and P. Deadman (2008) Illustrating a new conceptual design pattern for agent-based models and land use via five case studies: the MR POTATOHEAD framework. In Agent-Based Modeling in Natural Resource Management, A. López Paredes and C. Hernández Iglesias (Eds.), Cited by: §1, §2.2.2. [49] J. G. Polhill and N. M. Gotts (2009) Ontologies for transparent integrated human-natural system modelling. Landscape Ecology 24 (9), p. 1255. External Links: Document Cited by: §2.3. [50] J. G. Polhill, D. Parker, D. Brown, and V. Grimm (2008) Using the ODD protocol for describing three agent-based social simulation models of land-use change. Journal of Artificial Societies and Social Simulation 11 (2), p. 3. Cited by: §2.2.1. [51] J. G. Polhill (2010) ODD updated. Journal of Artificial Societies and Social Simulation 13 (4), p. 9. Cited by: §2.2.1. [52] J. G. Polhill (2015) Extracting OWL ontologies from agent-based models: a NetLogo extension. Journal of Artificial Societies and Social Simulation 18 (2), p. 15. External Links: Document Cited by: §2.3. [53] S. F. Railsback (2001) Concepts from complex adaptive systems as a framework for individual-based modelling. Ecological Modelling 139 (1), p. 47–62. External Links: Document Cited by: §1, §2.1. [54] M. Richiardi, R. Leombruni, N. Saam, and M. Sonnessa (2006) A common protocol for agent-based social simulation. Journal of Artificial Societies and Social Simulation 9 (1), p. 15. Cited by: §2.2.2. [55] P. O. Siebers, C. M. Macal, J. Garnett, D. Buxton, and M. Pidd (2010-09) Discrete-event simulation is dead, long live agent-based simulation!. Journal of Simulation 4 (3), p. 204–210. External Links: Document Cited by: §1. [56] P. E. Smaldino (2020) How to translate a verbal theory into a formal model. Social Psychology 51 (4), p. 207–218. External Links: Document Cited by: §2.3. [57] F. Squazzoni, J. G. Polhill, B. Edmonds, P. Ahrweiler, P. Antosz, G. Scholz, E. Chappin, M. Borit, H. Verhagen, F. Giardini, and N. Gilbert (2020) Computational models that matter during a global pandemic outbreak: a call to action. Journal of Artificial Societies and Social Simulation 23 (2), p. 10. External Links: Document Cited by: §1, §2.1. [58] H. Stone, C. R. MacIntyre, M. Kunasekaran, C. Poulos, and D. Heslop (2026) Generating a contact matrix for aged care settings in australia: an agent-based model study. Journal of Artificial Societies and Social Simulation 29 (2), p. 7. External Links: Document Cited by: §C.1, Table 37, Table 37, Table 37, Table 37, Table 37, Table 37, Table 37, Table 37, Table 37, Table 37, Table 37. [59] L. Szangolies, M. Rohwäder, H. Ahmed, F. Jahanmiri, A. Wagner, R. Souto-Veiga, V. Grimm, and C. A. Gallagher (2024) Visual ODD: a standardised visualisation illustrating the narrative of agent-based models. Journal of Artificial Societies and Social Simulation 27 (4), p. 1. External Links: Document, Link Cited by: §1, §2.2.1, §6.1. [60] C. Tian, T. Xiao, and J. Shang (2022-09) Channel differentiation strategy in a dual-channel supply chain considering free riding behavior. European Journal of Operational Research 301 (2), p. 473–485. External Links: Document Cited by: §1. [61] M. Tracy, M. Cerdá, and K. M. Keyes (2018-04) Agent-based modeling in public health: current applications and future directions. Annual Review of Public Health 39 (1), p. 77–94. External Links: Document Cited by: §1. [62] C. E. Vincenot (2018) How new concepts become universal scientific approaches: insights from citation network analysis of agent-based complex systems science. Proceedings of the Royal Society B: Biological Sciences 285 (1874), p. 20172360. External Links: Document Cited by: §2.2.1. [63] D. Waltemath, R. Adams, D. A. Beard, F. T. Bergmann, U. S. Bhalla, R. Britten, V. Chelliah, M. T. Cooling, J. Cooper, and E. J. Crampin (2011) Minimum information about a simulation experiment (MIASE). PLoS Computational Biology 7 (4), p. e1001122. External Links: Document Cited by: §2.2.3. [64] U. Wilensky (1999) NetLogo. Note: Center for Connected Learning and Computer-Based Modeling, Northwestern University, Evanston, IL External Links: Link Cited by: §1, §2.1. [65] M. D. Wilkinson, M. Dumontier, I. J. Aalbersberg, G. Appleton, M. Axton, A. Baak, N. Blomberg, J. Boiten, L. B. da Silva Santos, P. E. Bourne, et al. (2016) The FAIR guiding principles for scientific data management and stewardship. Scientific Data 3, p. 160018. External Links: Document Cited by: §2.2.3. [66] S. Wolf, J. Bouchaud, F. Cecconi, S. Cincotti, H. Dawid, H. Gintis, S. van der Hoog, C. C. Jaeger, D. V. Kovalevsky, A. Mandel, et al. (2013) Describing economic agent-based models – Dahlem ABM documentation guidelines. Complexity Economics 2 (1). Cited by: §2.2.2. [67] Y. Xu, W. Cai, H. Aydt, M. Lees, and D. Zehe (2017) Relaxing synchronization in parallel agent-based road traffic simulation. ACM Transactions on Modeling and Computer Simulation 27 (2), p. 14:1–14:24. External Links: Document Cited by: §3.4.3. [68] J. Zhang and D. T. Robinson (2021) Replication of an agent-based model using the Replication Standard. Environmental Modelling & Software 139, p. 105016. External Links: Document Cited by: §1, §2.1. Supplementary Material This appendix contains the full eight-table VISA specifications, the 19-rule consistency reports, and the reproduction figures for the three external, independently authored agent-based models studied in the paper (Rebellion; Wolf Sheep Stride Inheritance; AgedCareContactModel), together with the three LLM-executable skills that operationalize the protocol. Each specification below is the exact artifact on which the visa-check skill reported 19/19 PASS; it is reproduced here verbatim. Runnable Python reproductions, raw CSV outputs, the NetLogo reference trajectory, and the AnyLogic extractor are on the companion GitHub repository (https://github.com/AgentLabCn/visa). Appendix A Model 1 — Rebellion (reproduced) Epstein (2002) civil-violence model, as implemented in the NetLogo Rebellion model (Wilensky 2004). Reproduced cross-language (NetLogo → Python). The specification below passes 19/19 rules; the reproduction reproduces the punctuated-equilibrium signature (Fig. 5). A.1 VISA Specification — Rebellion Model (Exp1) Model. Civil-violence rebellion model of Epstein (2002), Modeling civil violence: An agent-based computational approach, PNAS 99(suppl. 3), as implemented in Wilensky (2004) as the NetLogo Rebellion model, shipped in the NetLogo Models Library (Sample Models → Social Science → Rebellion; NetLogo 6.x, C BY-NC-SA 3.0). Reproduction goal. Reproduce the punctuated-equilibrium / periodic-rebellion signature in the active-count time series (Epstein 2002, Fig. 1) by re-implementing the NetLogo model in Python directly from this VISA specification. The target is the qualitative signature — structurally determined and robust to the random seed — not a bit-exact trajectory. Authoring note (space). The model runs on a 40×40 toroidal grid with radius-V metric sensing. Following VISA’s principle that a spatial structure mediating agent interaction should be an explicit active agent, the grid is modelled as a Space agent G that owns the world geometry (width, height, and the two edge-wrap flags) and whose function (f5) answers vision-range queries: given an agent’s position and vision radius it returns the list of all agents within toroidal distance V. This list is an endogenous variable of each citizen and cop (i,tn_i,t), refreshed every tick by f5. The vision radius V itself belongs to the sensing agents (citizen/cop), not to the Grid — the Grid only reads it as a query argument. This mirrors the running example, where SensingNet is an explicit Space agent that maintains the network topology; here the Space agent maintains the metric topology. (VISA reserves implicit space only for models with no spatial interaction; Rebellion is not such a model.) Authoring note (what the Environment is — and is not). In VISA the Environment agent has two duties: (i) manage other agent instances (here: spawn the fixed citizen/cop populations at setup, governed by the initial densities); and (i) compute model-level statistics (here: the active / jailed / quiet counts). Every parameter that conceptually belongs to a decision-maker is attributed to that decision-maker, not dumped into the Environment: the citizen’s grievance/arrest parameters (L,τ,k,μL,τ,k,μ) and its sensing radius (V) sit on the Citizen, the sentence length (TmaxT_ ) and sensing radius (V) sit on the Cop, and the world geometry (Wx,Wy,wx,wyW_x,W_y,w_x,w_y) sits on the Grid. This keeps each agent’s T2 block a faithful list of its own state. Notation. Sets calligraphic (ℰ,,,E,G,A,P); instances lowercase + subscript; fixed counts N; exogenous params uppercase (L,V,Tmax,k,τ,Wx,WyL,V,T_ ,k,τ,W_x,W_y); endogenous lowercase + subscript with a time index (ai,t,ji,t,xi,t,yi,ta_i,t,j_i,t,x_i,t,y_i,t); the time index t marks a variable as endogenous and may be suppressed in prose for readability. A.1.1 T1 — Agent Name Set Instances Category Description Quantity Environment ℰE e Environment Spawns the fixed populations at setup; computes output aggregates Nℰ=1N_E=1 Grid G g Space Toroidal grid; owns world geometry; answers vision-range spatial queries N=1N_G=1 Citizen A a1,a2,…a_1,a_2,… Decision-maker Decides to rebel or stay quiet based on grievance and arrest risk N_A (fixed; set by init-agent-density, see T6a) Cop P p1,p2,…p_1,p_2,… Decision-maker Patrols; arrests a random active citizen within vision N_P (fixed; set by init-cop-density, see T6a) Populations are fixed (jail is a state, not removal) → all decision-maker quantities use N, satisfying the population-dynamics rule trivially (no create/remove functions). The Environment and Grid are singletons (=1=1); the concrete citizen/cop counts and the grid dimensions are exogenous inputs (T6a). A.1.2 T2 — Variable Variable Symbol Type Data type Value Unit Description Environment ℰE Init agent density — Exog.-homo. Float Input % used only at setup to spawn citizens Init cop density — Exog.-homo. Float Input % used only at setup to spawn cops Active count AtA_t Endog. Integer f4 agents # active citizens Jailed count JtJ_t Endog. Integer f4 agents # jailed citizens Quiet count QtQ_t Endog. Integer f4 agents # quiet citizens Grid G (Space) Width WxW_x Exog.-homo. Integer Input patches grid columns; toroidal extent Height WyW_y Exog.-homo. Integer Input patches grid rows; toroidal extent Wrap left–right wxw_x Exog.-homo. Boolean Input — horizontal edges connected Wrap top–bottom wyw_y Exog.-homo. Boolean Input — vertical edges connected Citizen A Risk aversion RiR_i Exog.-hetero. Float Input — drawn from a uniform distribution; fixed at birth Perceived hardship HiH_i Exog.-hetero. Float Input — drawn from a uniform distribution; fixed at birth Vision radius V Exog.-homo. Integer Input patches sensing radius; passed to f5 as a query argument Government legitimacy L Exog.-homo. Float Input — enters grievance gi,t=Hi(1−L)g_i,t=H_i(1-L) Rebellion threshold τ Exog.-homo. Float Input — g−RPg-RP threshold for rebelling Arrest constant k Exog.-homo. Float Input — scale in the arrest-probability formula Movement? μ Exog.-homo. Boolean Input — whether free citizens move x-coordinate xi,tx_i,t Endog. Integer f1 patch updated by f1 y-coordinate yi,ty_i,t Endog. Integer f1 patch updated by f1 Active flag ai,ta_i,t Endog.-dec. Boolean f1 — true if openly rebelling Jail term ji,tj_i,t Endog. Integer f2; f3 (ext) ticks set by arresting cop, decremented each tick Agents in vision i,tn_i,t Endog. List[∪A∪P] f5 (ext) agents all agents within toroidal distance V Cop P Max jail term TmaxT_ Exog.-homo. Integer Input ticks upper bound on a sentence Vision radius V Exog.-homo. Integer Input patches sensing radius; shared with Citizen (declared on both) x-coordinate xi,tx_i,t Endog. Integer f3 patch updated by f3 y-coordinate yi,ty_i,t Endog. Integer f3 patch updated by f3 Agents in vision i,tn_i,t Endog. List[∪A∪P] f5 (ext) agents all agents within toroidal distance V Transient quantities (not stored state): grievance gi,t=Hi(1−L)g_i,t=H_i(1-L) and estimated arrest probability Pi,t=1−exp(−k⌊ci,t/(1+αi,t)⌋)P_i,t=1- (-k c_i,t/(1+ _i,t) ) are recomputed inside f1 each tick from i,tn_i,t, where ci,tc_i,t = cops in vision and αi,t _i,t = active citizens in vision. A.1.3 T3 — Sensing The Grid (f5) realises the spatial modality: an agent “senses” another iff the toroidal Euclidean distance between their positions is ≤V≤ V (vision). Rows = observers (all non-Passive agents); columns = observed. Observer ℰE G A P ℰE (Env) ∅ ∅ ai,t,ji,ta_i,t,j_i,t ∅ G (Grid) ∅ ∅ xi,t,yi,tx_i,t,y_i,t xi,t,yi,tx_i,t,y_i,t A (Citizen) ∅ ∅ aj,t,j,t,xj,t,yj,ta_j,t,j_j,t,x_j,t,y_j,t xj,t,yj,tx_j,t,y_j,t P (Cop) ∅ ∅ aj,t,j,t,xj,t,yj,ta_j,t,j_j,t,x_j,t,y_j,t xj,t,yj,tx_j,t,y_j,t Reading the matrix: the Environment reads every citizen’s active/jail flags to form the aggregates; the Grid reads every citizen and cop position to compute the vision lists i,tn_i,t that it pushes to each agent; a citizen reads the attributes of the peers and cops that f5 has placed in its i,tn_i,t (active flag for the cop-to-active ratio in Pi,tP_i,t; jail-term and position to pick a move target free of free agents; cop positions to avoid cop-occupied patches); a cop reads citizens’ active flag and position (to find and move to a suspect) and peer cop positions (move validity). All citizen/cop parameters (L,τ,k,μ,Tmax,VL,τ,k,μ,T_ ,V) are self-attributes and so do not appear as cross-agent sensing. A.1.4 T4 — Internal Function Complex updates are given as numbered equations below the table and referenced by their equation number; the Self-state Update and External Effect columns record which endogenous variable is written and the equation that governs it. ID Function Method Decision basis Self-state update External effect Ref. Grid G f5 query_vision Spatial query (xi,t,yi,t)∀i(x_i,t,y_i,t)\,∀ i (T3); V — i,t←n_i,t← (5), ∀i∈∪∀ i — Citizen A f1 rebel_or_move Conditional + Random i,tn_i,t; Hi,Ri,L,τ,k,μH_i,R_i,L,τ,k,μ (self) xi,t,yi,t,ai,tx_i,t,y_i,t,a_i,t via (7) — [14] f2 decrement_jail Decrement ji,tj_i,t (self) ji,t←ji,t−1j_i,t← j_i,t-1 — — Cop P f3 patrol_and_arrest Random + Random selection i,tn_i,t; TmaxT_ (self) xi,t,yi,tx_i,t,y_i,t via (8) as,t,js,ta_s,t,j_s,t via (9) [14] Environment ℰE f4 compute_counts Count ai,t,ji,t∀i∈a_i,t,j_i,t\,∀ i (T3) At,Jt,QtA_t,J_t,Q_t via (10) — — Behavioural equations. The Grid’s vision query is i,t=a′∈∪:dtor((xi,t,yi,t),(xa′,t,ya′,t))≤V.n_i,t= \\,a \;:\;d_tor ((x_i,t,y_i,t),\,(x_a ,t,y_a ,t) )≤ V\, \. (5) A free citizen (ji,t=0j_i,t=0) evaluates grievance and arrest probability, gi,t=Hi(1−L),Pi,t=1−exp(−k⌊ci,t1+αi,t⌋),g_i,t=H_i(1-L), P_i,t=1- \! (\!-k c_i,t1+ _i,t ), (6) with ci,t=|i,t∩|c_i,t=|n_i,t | (cops in vision) and αi,t=|a′∈i,t∩:a′,t| _i,t=|\a _i,t :a_a ,t\| (active citizens in vision), and then rebels and/or moves: ai,t←[gi,t−RiPi,t>τ],(xi,t,yi,t)←Unifℳi(if μ∧ji,t=0).a_i,t 1 [\,g_i,t-R_i\,P_i,t>τ\, ], (x_i,t,y_i,t) \,M_i\ \ (if μ j_i,t=0). (7) Here ℳi=(x,y):dtor((x,y),(xi,t,yi,t))≤V,no cop and no free citizen at (x,y)M_i=\(x,y):d_tor((x,y),(x_i,t,y_i,t))≤ V,\ no cop and no free citizen at (x,y)\ is the set of admissible move patches in vision. The cop moves likewise and arrests one active citizen: (xi,t,yi,t)←Unifℳi,s∼Unifa′∈i,t∩:a′,t.(x_i,t,y_i,t) \,M_i, s \a _i,t :a_a ,t\. (8) as,t←false,js,t∼U0,…,Tmax−1.a_s,t , j_s,t U\0,…,T_ -1\. (9) The Environment’s aggregates are At=|a′∈:a′,t|,Jt=|a′∈:ja′,t>0|,Qt=N−At−Jt.A_t= |\a :a_a ,t\ |,\;\;J_t= |\a :j_a ,t>0\ |,\;\;Q_t=N_A-A_t-J_t. (10) The floor in Pi,tP_i,t (6) is the well-known deviation from Epstein’s original formula: without it, the model does not exhibit punctuated equilibrium. Its effect is Pi,t≈0P_i,t≈ 0 when cops are outnumbered by active citizens, ≈0.99≈ 0.99 otherwise. A.1.5 T5 — Associated Data ID Title Type Temporal Source Collection Pre-processing #Rec. Avail. (empty — the model has no stand-alone dataset) The model has no stand-alone dataset: it is neither backed by an empirical dataset nor by a synthetic one. Ri,HiR_i,H_i are drawn from a uniform distribution in the sampling step itself, and every structural parameter is an author-assumed value (the canonical settings reported in Epstein 2002). With no separable data record backing any parameter, T5 is empty; accordingly every T6a entry has Data source == Author (no d-ID to cite). A.1.6 T6 — Input and Output (a) Input Symbol Value / Distribution Data source Derivation Algorithm Ref. Environment ℰE init-agent-density 70 (% of patches) Author Assumed — — init-cop-density 4 (% of patches) Author Assumed — — Citizen A L 0.82 Author Assumed — — τ 0.1 Author Assumed — — k 2.3 Author Assumed — — μ true Author Assumed — — V 7 Author Assumed — — RiR_i U(0,1)U(0,1) Author Computed uniform sampling — HiH_i U(0,1)U(0,1) Author Computed uniform sampling — Cop P TmaxT_ 30 Author Assumed — — Grid G Wx,WyW_x,W_y 40, 40 Author Assumed — — wx,wyw_x,w_y true, true Author Assumed — — (b) Output Symbol Indicator Formula Data type Unit Freq. Desc. AtA_t Active citizens ∑ai∈[ai,t] _a_i 1[a_i,t] Integer agents 1 openly rebelling JtJ_t Jailed citizens ∑ai∈[ji,t>0] _a_i 1[j_i,t>0] Integer agents 1 in jail QtQ_t Quiet citizens N−At−JtN_A-A_t-J_t Integer agents 1 inactive & free A.1.7 T7 — Schedule (a) Execution Step Agent ID Function Exec. mode Condition 1 G f5 query_vision Synchronous every tick 2 A f1 rebel_or_move Random-order free citizen 2 P f3 patrol_and_arrest Random-order — 3 A f2 decrement_jail Random-order ji,t>0j_i,t>0 4 ℰE f4 compute_counts Synchronous every tick Step 2’s two rows are a single interleaved random-order activation (citizens and cops shuffled together): each agent atomically performs its move then its rebel/arrest decision before the next agent acts (first-mover faithful). Splitting them into two rows only separates the two functions; the Random-order mode eliminates systematic ordering bias. f5 (Step 1) refreshes every i,tn_i,t before any agent acts, so all decision-makers see the start-of-tick configuration. (b) Termination ID Indicator Condition Description Value source/ref Termination logic c1 t t≥1000t≥ 1000 Reproduction horizon reached Author assumed Stop when c1c_1 The model runs indefinitely; c1 fixes the reproduction run length. A.1.8 T8 — Validation ID Validation object Benchmark data Method Indicator Passing cond. Ref. Output level v1 Active-count time series AtA_t Epstein 2002 Fig. 1 (qualitative) Peak/episode detection + visual inspection AtA_t over t periodic rebellion episodes (peaks ≫0 0) separated by quiescent troughs [14] v2 Arrest-probability floor effect the formula itself unit check of Pi,tP_i,t Pi,tP_i,t ≈0≈ 0 when ci,t<αi,tc_i,t< _i,t; ≈0.99≈ 0.99 when ci,t≥αi,tc_i,t≥ _i,t — v3 Population conservation identity At+Jt+Qt=NA_t+J_t+Q_t=N_A invariant check At+Jt+QtA_t+J_t+Q_t =N=N_A at every t — v1 is the headline reproduction criterion (punctuated equilibrium). Author’s note. Epstein (2002) reports the punctuated-equilibrium result (Fig.~1) but states no formal validation criteria. The three entries above (v1–v3) are authored for this case study to illustrate the T8 validation table; they are not transcribed from the source paper. A.1.9 Consistency check (19 rules) Within-table (r1–r4) and cross-table (r5–r19), per the revised VISA rule set. Rule Res. Note r1 Variable-type coverage & time-indexing PASS all T2 rows carry a leaf type; every endogenous variable carries the time index t (xi,t,yi,t,ai,t,ji,t,i,t,At,Jt,Qtx_i,t,y_i,t,a_i,t,j_i,t,n_i,t,A_t,J_t,Q_t) r2 Function-ID uniqueness PASS f1–f5 unique r3 Function productivity PASS f1 writes xi,t,yi,t,ai,tx_i,t,y_i,t,a_i,t; f2 writes ji,tj_i,t; f3 writes pos + ext as,t,js,ta_s,t,j_s,t; f4 writes At,Jt,QtA_t,J_t,Q_t; f5 writes ext i,tn_i,t r4 Step–Exec.mode consistency PASS Step 1 = Synchronous (f5); Step 2 = Random-order (f1,f3); Step 3 = Random-order (f2); Step 4 = Synchronous (f4) r5 Same-type (peer) sensing PASS ℰ,E,G N=1N=1→∅ (no peers); ,A,P n>1n>1→ peer sets aj,t,j,t,xj,t,yj,ta_j,t,j_j,t,x_j,t,y_j,t and xj,t,yj,tx_j,t,y_j,t (self implicit) r6 Passive-agent implications PASS no Passive agents r7 Observer-row completeness PASS ℰ,,,E,G,A,P each have exactly one row r8 Population-dynamics consistency PASS all quantities fixed (N); no create/remove functions r9 Active-agent function coverage PASS ℰE→ 4; G→ 5; A→ 1,f2; P→ 3 r10 Variable observability PASS all vars sensed (spatially bounded by V via i,tn_i,t) or self-read r11 Endogenous-variable completeness PASS At,Jt,QtA_t,J_t,Q_t← 4; citizen xi,t,yi,t,ai,tx_i,t,y_i,t,a_i,t← 1, ji,tj_i,t← 2/f3(ext), i,tn_i,t← 5(ext); cop pos← 3, i,tn_i,t← 5(ext); every referenced f-ID exists r12 Self-state-update validity PASS all Self-state vars are endogenous of the owning agent r13 External-effect validity PASS f3 ext writes citizen as,t,js,ta_s,t,j_s,t; f5 ext writes i,tn_i,t (endogenous of citizen/cop) r14 Information-access validation PASS every Decision-basis var is a self-attribute or T3-authorized (within vision V, realised by i,tn_i,t) r15 Input–output coverage (bidirectional) PASS every Input var has a T6a entry; every T2 “Input” var has a value; At,Jt,QtA_t,J_t,Q_t computable from T2 r16 Schedule coverage (bidirectional) PASS f1,f2,f3,f4,f5 all appear in T7a; every T7a ID exists in T4 r17 Termination-indicator source PASS c1 uses t (global time index, exempt) r18 Validation-object coverage PASS v1→ _t; v2→ ,tP_i,t (computed in f1); v3→ +Jt+QtA_t+J_t+Q_t; all trace to T2/T6b r19 Data-reference resolution PASS T5 is empty (no stand-alone dataset); all T6a sources are Author; no empirical data references to resolve Summary: 19/19 PASS. Figure 5: Rebellion reproduction — active-citizen count over time. The NetLogo 6.4 reference (3 runs) and the Python re-implementation generated from the VISA specification (3 seeds) are shown as min–max bands with solid means. The two use different RNGs, so trajectories are not bit-identical, but the punctuated-equilibrium signature is reproduced cross-language. T8 v1–v3: PASS. Appendix B Model 2 — Wolf Sheep Stride Inheritance (reproduced) Novak & Wilensky (2006); reproduced cross-language (NetLogo → Python). The specification passes 19/19 rules. Every curve in Figs. 6–8 was produced by Python code generated directly from the eight-table VISA specification via the code skill; the reproduction target is the model’s published Info-tab predictions, not a bit-exact trajectory. T8 v2–v5 PASS, v1 directional. B.1 VISA Specification — Wolf Sheep Stride Inheritance Model (Exp2) Model. Wolf Sheep Stride Inheritance — Novak, M. & Wilensky, U. (2006), NetLogo Wolf Sheep Stride Inheritance model, shipped in the NetLogo Models Library (Sample Models → Biology → Wolf Sheep Stride Inheritance; CCL, Northwestern Univ.; NetLogo 6.x, C BY-NC-SA 3.0) — a variation on Wolf-Sheep Predation in which stride length is an inheritable, mutating trait, so natural selection on movement distance can be observed. Reproduction goal. Reproduce the model’s two signature results directly from this specification (cross-language, NetLogo → Python, qualitative — not bit-exact): 1. Sheep mean stride converges to ≈1≈ 1 when the stride-length energy penalty is on (the Info tab’s headline result: “sheep typically converge on an average stride length close to 1”). 2. With the penalty off, sheep stride grows without bound (≫1 1) — the counterfactual that isolates why ≈1≈ 1 is the equilibrium. Plus the generic predator-prey behaviour inherited from Wolf-Sheep Predation: parameter-dependent extinction (which species survives) and Lotka–Volterra-style population oscillations. Authoring note (space and grass). The world is a 61×61 toroidal continuous space (min/max-pxcor = ± 30, wrapping in both axes; patch size 6). Two spatial structures that the original code folds into “patches” are made into explicit VISA agents: • a Grid (Space) agent G that owns the world geometry (width, height, and the two edge-wrap flags), maintains the position relationships among the currently-alive animals, and answers patch-co-location queries — the spatial primitive the model actually uses (an animal interacts with whatever is on its patch after a forward move of length ℓ ). f10 writes, into each animal, the co-location list it needs (γi,t _i,t = grass-at-my-patch for a sheep; j,th_j,t = sheep-at-my-patch for a wolf). • a GrassFieldCell agent ℱF — one per patch — whose only behaviour is to age its own regrowth clock and turn green (f9). This makes the grass field an active agent set rather than an Environment-owned matrix. As in Exp1, this follows VISA’s principle that a spatial structure mediating interaction is an explicit Space agent (cf. the running example’s SensingNet). Notation. Sets calligraphic (ℰ,,ℱ,,E,G,F,S,W); instances lowercase + subscript; variable quantities n (birth/death); fixed N; exogenous params/constants uppercase (Mmax,Smax,Gf,r,δ,Wx,Wy,…M_ ,S_ ,G_f,r,δ,W_x,W_y,…); endogenous lowercase + subscript with a time index (ei,t,xi,t,yi,t,θi,t,gf,te_i,t,x_i,t,y_i,t, _i,t,g_f,t); the time index t marks a variable as endogenous and may be suppressed in prose for readability. B.1.1 T1 — Agent Name Set Instances Category Description Quantity Environment ℰE e Environment Spawns initial populations; computes output aggregates Nℰ=1N_E=1 Grid G g Space Toroidal continuous grid; owns world geometry; answers patch-co-location queries N=1N_G=1 GrassFieldCell ℱF f1,f2,…f_1,f_2,… Decision-maker One patch cell; ages its regrowth clock and turns green NℱN_F (fixed; one per patch, see T6a) Sheep S s1,s2,…s_1,s_2,… Decision-maker Eats grass, metabolises, reproduces (inheritable stride), dies n_S (variable; birth/death) Wolf W w1,w2,…w_1,w_2,… Decision-maker Catches sheep, metabolises, reproduces (inheritable stride), dies n_W (variable; birth/death) Sheep and Wolf have variable populations (n, not N) → r8 requires each to own a creation function (f3/f7, reproduce) and a removal function (f4/f8, die). The Grid, GrassFieldCell, and Environment are fixed-quantity singletons/multitons (N). GrassFieldCell is categorised Decision-maker because it owns an endogenous state and a function (the regrowth rule); its “decision” is the deterministic countdown trigger, the only available fit in VISA’s four categories. B.1.2 T2 — Variable Variable Symbol Type Data type Value Unit Description Environment ℰE Initial sheep count n0n_S^0 Exog.-homo. Integer Input sheep initial population; used at setup Initial wolf count n0n_W^0 Exog.-homo. Integer Input wolves initial population; used at setup Sheep cap NmaxN_ Exog.-homo. Integer Input sheep overpopulation termination guard Sheep count StS_t Endog. Integer f11 sheep |||S| Wolf count WtW_t Endog. Integer f11 wolves |||W| Green-patch count RtR_t Endog. Integer f11 patches ∑fgf,t _fg_f,t Mean sheep stride ℓ¯ts ^s_t Endog. Float f11 patches meaniℓimean_i\, _i Mean wolf stride ℓ¯tw ^w_t Endog. Float f11 patches meanjℓjmean_j\, _j Grid G (Space) Width WxW_x Exog.-homo. Integer Input patches grid columns; toroidal extent Height WyW_y Exog.-homo. Integer Input patches grid rows; toroidal extent Wrap left–right wxw_x Exog.-homo. Boolean Input — horizontal edges connected Wrap top–bottom wyw_y Exog.-homo. Boolean Input — vertical edges connected GrassFieldCell ℱF Grass regrowth time TgT_g Exog.-homo. Integer Input ticks brown→ delay Green flag gf,tg_f,t Endog. Boolean f9; f2 (ext) — true = green, false = brown Regrowth countdown cf,tc_f,t Endog. Integer f9 ticks brown-patch clock Sheep S Energy ei,te_i,t Endog. Float f1; f2; f3 energy drives death/reproduction Stride length ℓi _i Exog.-hetero. Float Input (birth) patches inherited + mutated at birth; constant per agent Initial sheep stride ℓs0 ^0_s Exog.-homo. Float Input patches stride assigned to a hatched sheep at setup Sheep stride drift δs _s Exog.-homo. Float Input patches half-width of the per-birth mutation Sheep gain from food GfsG_f^s Exog.-homo. Float Input energy energy gained per grass eaten Sheep reproduce chance rsr_s Exog.-homo. Float Input % per-tick reproduction probability Max energy MmaxM_ Exog.-homo. Float Input energy energy cap; declared on both Sheep & Wolf Reproduction threshold MminM_ Exog.-homo. Float Input energy min energy to reproduce; declared on both Max stride SmaxS_ Exog.-homo. Float Input patches stride-length upper clamp; declared on both Stride-energy penalty? π Exog.-homo. Boolean Input — whether stride costs energy; declared on both x-coordinate xi,tx_i,t Endog. Float f1 patch wrapped to torus y-coordinate yi,ty_i,t Endog. Float f1 patch wrapped to torus Heading θi,t _i,t Endog. Float f1 deg [0,360)[0,360); 0=0= +y (north) Grass at my patch γi,t _i,t Endog. Boolean f10 (ext) — green flag of the co-located GrassFieldCell Wolf W Energy ej,te_j,t Endog. Float f5; f6; f7 energy drives death/reproduction Stride length ℓj _j Exog.-hetero. Float Input (birth) patches inherited + mutated at birth; constant per agent Initial wolf stride ℓw0 ^0_w Exog.-homo. Float Input patches stride assigned to a hatched wolf at setup Wolf stride drift δw _w Exog.-homo. Float Input patches half-width of the per-birth mutation Wolf gain from food GfwG_f^w Exog.-homo. Float Input energy energy gained per sheep caught Wolf reproduce chance rwr_w Exog.-homo. Float Input % per-tick reproduction probability Max energy MmaxM_ Exog.-homo. Float Input energy energy cap; declared on both Sheep & Wolf Reproduction threshold MminM_ Exog.-homo. Float Input energy min energy to reproduce; declared on both Max stride SmaxS_ Exog.-homo. Float Input patches stride-length upper clamp; declared on both Stride-energy penalty? π Exog.-homo. Boolean Input — whether stride costs energy; declared on both x-coordinate xj,tx_j,t Endog. Float f5 patch wrapped to torus y-coordinate yj,ty_j,t Endog. Float f5 patch wrapped to torus Heading θj,t _j,t Endog. Float f5 deg [0,360)[0,360); 0=0= +y (north) Sheep at my patch j,th_j,t Endog. List[S] f10 (ext) sheep co-located sheep (for catching) Why stride is Exog.-hetero., not Endogenous. A given animal’s stride is set once, at birth (initial slider value, or parent-stride + mutation for offspring) and is never updated by any function acting on that agent. It is therefore heterogeneous across agents yet not an endogenous state — exactly parallel to Rebellion’s risk-aversion Ri∼U(0,1)R_i U(0,1) (Exp1). The mutation is part of the offspring-creation step (f3/f7 external effect, (15)), not an update to an existing agent. Transient quantities (not stored): the turn deltas and mutation noise are drawn fresh inside f1/f3/f5/f7 each call. B.1.3 T3 — Sensing The Grid (f10) realises the spatial modality: animals interact with what is on their own patch (round(x),round(y)round(x),round(y)). Rows = observers; columns = observed. Observer ℰE G ℱF S W ℰE (Env) ∅ ∅ gf,tg_f,t ei,t,ℓi,xi,t,yi,te_i,t, _i,x_i,t,y_i,t ej,t,ℓj,xj,t,yj,te_j,t, _j,x_j,t,y_j,t G (Grid) ∅ ∅ gf,tg_f,t xi,t,yi,tx_i,t,y_i,t xj,t,yj,tx_j,t,y_j,t ℱF (Grass) ∅ ∅ ∅ ∅ ∅ S (Sheep) ∅ ∅ gf,tg_f,t ∅ ∅ W (Wolf) ∅ ∅ ∅ xi,t,yi,tx_i,t,y_i,t ∅ Reading the matrix: the Environment reads every animal’s energy/stride/position and every cell’s green flag to form the aggregates (f11). The Grid reads animal positions and grass flags to compute the co-location lists it pushes to each animal. A sheep reads the green flag of the grass cell on its own patch (γi,t _i,t, to eat) and its own state — but no peer sheep and no wolves (movement is an undirected random walk, not chase/flee). A wolf reads the positions of co-located sheep (to pick a uniformly random co-located prey); it does not sense other wolves. Every same-type diagonal is ∅ : neither breed has any same-type sensing, and the singleton types have no peers (valid per r5; self-observation is implicit). B.1.4 T4 — Internal Function Complex updates are given as numbered equations below the table; the Self-state Update and External Effect columns record which endogenous variable is written and the equation that governs it. ID Function Method Decision basis Self-state update External effect Ref. Grid G f10 query_colocation Spatial query animal positions + gf,tg_f,t (T3) — γi,t←gf∗(i),t _i,t← g_f^*(i),t for each sheep; j,t←h_j,t← sheep on j’s patch for each wolf — Sheep S f1 move_sheep Random walk + metabolism θi,t,ℓi,ei,t,π _i,t, _i,e_i,t,π (self) θi,t,xi,t,yi,t,ei,t _i,t,x_i,t,y_i,t,e_i,t via (11) — — f2 eat_grass Conditional γi,t _i,t (self) ei,te_i,t via (12) if γi,t _i,t: gf∗(i),t←g_f^*(i),t← False — f3 reproduce_sheep Probabilistic + create ei,t,ℓi,θi,t,xi,t,yi,te_i,t, _i, _i,t,x_i,t,y_i,t; rs,Mmin,δs,Smaxr_s,M_ , _s,S_ (self) if condition: ei,t←ei,t/2e_i,t← e_i,t/2 (15) creates offspring snew∈s_new [45] f4 die_sheep Conditional removal ei,te_i,t (self) if ei,t<0e_i,t<0: remove self from S — — Wolf W f5 move_wolf Random walk + metabolism θj,t,ℓj,ej,t,π _j,t, _j,e_j,t,π (self) θj,t,xj,t,yj,t,ej,t _j,t,x_j,t,y_j,t,e_j,t via (11) — — f6 catch_sheep Uniform selection j,th_j,t (self); Gfw,MmaxG_f^w,M_ (self) ej,te_j,t via (13) remove chosen sks_k from S [45] f7 reproduce_wolf Probabilistic + create ej,t,ℓj,θj,t,xj,t,yj,te_j,t, _j, _j,t,x_j,t,y_j,t; rw,Mmin,δw,Smaxr_w,M_ , _w,S_ (self) if condition: ej,t←ej,t/2e_j,t← e_j,t/2 (15) creates offspring wnew∈w_new [45] f8 die_wolf Conditional removal ej,te_j,t (self) if ej,t<0e_j,t<0: remove self from W — — GrassFieldCell ℱF f9 grow_grass Field countdown cf,t,gf,tc_f,t,g_f,t (self) cf,t,gf,tc_f,t,g_f,t via (14) — — Environment ℰE f11 compute_counts Aggregation all si∈s_i , wj∈w_j , f∈ℱf (T3) St,Wt,Rt,ℓ¯ts,ℓ¯twS_t,W_t,R_t, ^s_t, ^w_t via (18) — — Here f∗(i)f^*(i) denotes the GrassFieldCell at sheep i’s patch, i.e. round(xi,t)=round(xf∗)round(x_i,t)=round(x_f^*) and likewise for y. f1/f5 (move) and f3/f7 (reproduce) share identical logic across breeds; they are listed separately because they belong to different agent types with different sensing. Behavioural equations. The move + metabolism step (f1 sheep, f5 wolf) is θ←θ+U(0,50)−U(0,50),(x,y)←wrap((x,y)+fwd(θ,ℓ)),e←e−0.5−[π]ℓ,θ←θ+U(0,50)-U(0,50), (x,y) ((x,y)+fwd(θ, ) ), e← e-0.5-1[π]\, , (11) with the breed’s own subscripts (i/j) and stride (ℓi _i/ℓj _j). Eating, catching, growing, and reproducing are if γi,t:ei,t←min(Mmax,ei,t+Gfs)if _i,t:\;e_i,t← (M_ ,\,e_i,t+G_f^s) (12) if j,t≠∅:pick sk∼Unif(j,t),ej,t←min(Mmax,ej,t+Gfw)if h_j,t≠ :\;pick s_k (h_j,t),\;e_j,t← (M_ ,\,e_j,t+G_f^w) (13) if ¬gf,t:cf,t←cf,t−1;if cf,t≤0:gf,t←True,cf,t←Tgif g_f,t:\;c_f,t← c_f,t-1; c_f,t≤ 0:\;g_f,t ,\;c_f,t← T_g (14) Reproduction (f3 sheep, f7 wolf) fires when a uniform draw beats the reproduce chance and energy exceeds the threshold; the parent halves its energy and creates one offspring: if U(0,100)<r∧e>Mmin:e←e/2,create offspring (ℓ′,e′,θ′,x′,y′)if U(0,100)<r e>M_ : e← e/2, offspring ( ,e ,θ ,x ,y ) (15) with the offspring’s traits ℓ′=mutate(ℓ,δ,Smax),e′=e,θ′=θ+U(0,360),(x′,y′)=wrap((x,y)+fwd(θ′,1)), =mutate( ,δ,S_ ), e =e, θ =θ+U(0,360), (x ,y )=wrap ((x,y)+fwd(θ ,1) ), (16) where r,δr,δ are the breed’s reproduce-chance / drift (rs,δsr_s, _s for sheep; rw,δwr_w, _w for wolf). The mutation operator mutatemutate adds symmetric uniform noise and clamps the result: ℓ′=ℓ+U(0,δ)−U(0,δ),mutate=0ℓ′<0Smaxℓ>Smaxℓ′otherwise. = +U(0,δ)-U(0,δ), = cases0& <0\\ S_ & >S_ \\ &otherwise. cases (17) The upper branch tests the parent’s stride ℓ , not the noisy ℓ′ . Given the invariant ℓ≤Smax ≤ S_ at birth, that branch fires only one generation after an overshoot, so the effective bound is the reflecting lower clamp at 0; this is part of the model’s selection dynamics, not a defect. Finally, the aggregates (f11) are St=||,Wt=||,Rt=∑fgf,t,ℓ¯ts=meaniℓi,ℓ¯tw=meanjℓj.S_t=|S|,\;\;W_t=|W|,\;\;R_t= _fg_f,t,\;\; ^s_t=mean_i _i,\;\; ^w_t=mean_j _j. (18) B.1.5 T5 — Associated Data ID Title Type Temporal Source Collection Pre-processing #Rec. Avail. (empty — the model has no stand-alone dataset) As in Exp1, the model has no stand-alone dataset: it is neither backed by an empirical dataset nor by a synthetic one. All structural parameters are author-assumed values (the canonical settings reported in Novak & Wilensky 2006), and initial positions/energies/grass are drawn from uniform distributions in the sampling step itself. With no separable data record backing any parameter, T5 is empty; accordingly every T6a entry has Data source == Author (no d-ID to cite). B.1.6 T6 — Input and Output (a) Input Symbol Value / Distribution Data source Derivation Algorithm Ref. Environment ℰE n0n_S^0 64 Author Assumed — — n0n_W^0 30 Author Assumed — — NmaxN_ 30000 Author Assumed — — Grid G Wx,WyW_x,W_y 61, 61 Author Assumed — — wx,wyw_x,w_y true, true Author Assumed — — GrassFieldCell ℱF TgT_g 138 Author Assumed — — grass countdown (per cell) U0,…,137U\0,…,137\ Author Computed integer uniform — grass flag (per cell) Bernoulli(0.5) Author Computed integer uniform — Sheep S ℓs0 ^0_s 0.2 Author Assumed — — δs _s 0.2 Author Assumed — — GfsG_f^s 20 Author Assumed — — rsr_s 5 Author Assumed — — Wolf W ℓw0 ^0_w 1.0 Author Assumed — — δw _w 0.24 Author Assumed — — GfwG_f^w 20 Author Assumed — — rwr_w 6 Author Assumed — — Both animals ∪S (shared) Mmax,Mmin,SmaxM_ ,M_ ,S_ 500, 200, 3 Author Assumed — — π true / false Author Assumed — — init energy (per animal) U0,…,499U\0,…,499\ Author Computed integer uniform — init position (per animal) U(−30.5,30.5)2U(-30.5,30.5)^2 Author Computed continuous uniform — (b) Output Symbol Indicator Formula Data type Unit Freq. Desc. StS_t Sheep population |||S| Integer sheep 1 live sheep WtW_t Wolf population |||W| Integer wolves 1 live wolves Rt/4R_t/4 Grass (scaled) ∑fgf,t/4 _fg_f,t/4 Float patches 1 green patches (÷ 4 for plot scale) ℓ¯ts ^s_t Mean sheep stride meaniℓimean_i _i Float patches 1 headline selection indicator ℓ¯tw ^w_t Mean wolf stride meanjℓjmean_j _j Float patches 1 wolf selection indicator B.1.7 T7 — Schedule (a) Execution Step Agent ID Function Exec. mode Condition 1 G f10 query_colocation Synchronous on demand (per animal as it acts) 2 S f1 move_sheep Random-order live sheep 2 S f2 eat_grass Random-order live sheep 2 S f4 die_sheep Random-order live sheep 2 S f3 reproduce_sheep Random-order survived 3 W f5 move_wolf Random-order live wolf 3 W f6 catch_sheep Random-order live wolf 3 W f8 die_wolf Random-order live wolf 3 W f7 reproduce_wolf Random-order survived 4 ℱF f9 grow_grass Synchronous every brown cell 5 ℰE f11 compute_counts Synchronous every tick Composite schedule. The tick is a breed-sequential composite: the sheep block (Step 2) runs to completion before the wolf block (Step 3), which runs to completion before the grass block (Step 4). Within each block, agents are iterated in random order (Random-order). The Grid (Step 1) is a live spatial index: each co-location query is evaluated for the animal that is currently acting, so wolves (Step 3) see the sheep distribution left by Step 2. The sheep-before-wolves ordering is load-bearing: a sheep born in Step 2 is not processed again in Step 2 (population snapshot) and is a valid target for wolves in Step 3; a wolf’s victim (removed in Step 3) will not act again. (Staged execution is a composite mode in VISA, built from Random-order base blocks.) Per-animal sub-ordering within a block (Step 2, sheep): move+metabolise → eat-grass → maybe-die → reproduce. Death is checked before reproduction, so a sheep that starves does not also reproduce that tick. (b) Termination ID Indicator Condition Description Value source/ref Termination logic c1 St+WtS_t+W_t =0=0 Extinction of all animals Model stopping rule Stop when c1∨c2∨c3c_1 c_2 c_3 c2 Wt,StW_t,\,S_t Wt=0∧St>NmaxW_t=0 S_t>N_ Wolves extinct; sheep overpopulate Model stopping rule c3 t t≥Tt≥ T Reproduction horizon reached Author assumed c1/c2 are the model’s own stopping rules (total extinction; wolves extinct with sheep over the cap); c3 bounds the reproduction run length (e.g., T=1500T=1500). The simulation stops as soon as any of the three fires. B.1.8 T8 — Validation ID Validation object Benchmark data Method Indicator Passing cond. Ref. Output level v1 Sheep stride trajectory ℓ¯ts ^s_t (penalty on) Novak & Wilensky 2006: ”sheep typically converge on an average stride length close to 1” time-series + end-state mean ℓ¯ts ^s_t converges toward ≈1≈ 1 (end-state mean ∈[0.5,1.5]∈[0.5,1.5]) [45] v2 Sheep stride trajectory (penalty off) Novak & Wilensky 2006: ”they will become faster and faster” time-series trend ℓ¯ts ^s_t grows monotonically away from 1 (end-state ≫1 1, e.g. >1.5>1.5 and rising) [45] v3 Extinction outcome Wolf-Sheep Predation family behaviour per-seed end-state classification (ST,WT)(S_T,W_T) reproduces parameter-dependent outcome (coexistence / wolf extinction / total extinction) across seeds [45] v4 Predator-prey oscillation Lotka–Volterra signature peak/trough detection in St,WtS_t,W_t St,WtS_t,W_t out-of-phase sheep–wolf oscillations while both persist — v5 Energy bound identity 0≤ej,t≤Mmax0≤ e_j,t≤ M_ invariant check maxiei,t _ie_i,t ≤Mmax≤ M_ at every t — v1 and v2 are the headline reproduction criteria — together they show the emergent selection equilibrium (≈1≈ 1) and isolate the energy penalty as its cause. v3 reproduces the inherited Wolf-Sheep Predation extinction dynamics; v4 the predator-prey cycles; v5 is a structural invariant. Author’s note. Novak & Wilensky (2006) state the headline behaviors qualitatively but give no formal validation criteria. The five entries above (v1–v5) are authored for this case study to illustrate the T8 validation table, not transcribed from the source paper. B.1.9 Consistency check (19 rules) Within-table (r1–r4) and cross-table (r5–r19), per the revised VISA rule set. Rule Res. Note r1 Variable-type coverage & time-indexing PASS all T2 rows carry a leaf type; every endogenous variable carries the time index t (ei,t,xi,t,yi,t,θi,t,γi,t,gf,t,cf,t,St,Wt,Rt,ℓ¯ts,ℓ¯tw,j,te_i,t,x_i,t,y_i,t, _i,t, _i,t,g_f,t,c_f,t,S_t,W_t,R_t, ^s_t, ^w_t,h_j,t) r2 Function-ID uniqueness PASS f1–f11 unique; every f-ID in T2’s Value column exists in T4 r3 Function productivity PASS f1 writes θ,x,y,eθ,x,y,e; f2 writes e+ext gf,tg_f,t; f3 writes e+creates instance; f4 removes instance (→ _S); f5–f8 likewise; f9 writes gf,t,cf,tg_f,t,c_f,t; f10 writes ext γi,t,j,t _i,t,h_j,t; f11 writes 5 aggregates. f4/f8 are removal functions (r8 pattern): their productivity is the population change n/n_S/n_W. r4 Step–Exec.mode consistency PASS Step 1 = Synchronous (f10); Steps 2–3 = Random-order (sheep/wolf blocks); Step 4 = Synchronous (f9); Step 5 = Synchronous (f11); no conflicting modes within a step r5 Same-type (peer) sensing PASS ℰ,E,G N=1N=1→∅ ; ℱF fixed but no same-type sensing→∅ ; ,S,W n>1n>1→∅ peer set (no same-type sensing; self implicit) r6 Passive-agent implications PASS no Passive agents r7 Observer-row completeness PASS ℰ,,ℱ,,E,G,F,S,W each have exactly one row r8 Population-dynamics consistency PASS n_S→ f3 + remove f4; n_W→ f7 + remove f8; Nℰ,N,NℱN_E,N_G,N_F→ r9 Active-agent function coverage PASS ℰE→ 11; G→ 10; ℱF→ 9; S→ 1,f2,f3,f4; W→ 5,f6,f7,f8 r10 Variable observability PASS all vars self-read or T3-authorized (grass green read via γi,t _i,t/gf,tg_f,t; wolf reads co-located sheep positions) r11 Endogenous-variable completeness PASS every endog var written by ≥ 1 existing f-ID: sheep e,θ,x,ye,θ,x,y← 1, e← 2,f3, γ← 10(ext); wolf ← 5,f6,f7, h← 10(ext); grass gf,t,cf,tg_f,t,c_f,t← 9 (+f2 ext); aggregates← 11 r12 Self-state-update validity PASS all Self-state vars are endogenous of the owning agent r13 External-effect validity PASS f2 ext writes gf,tg_f,t (GrassFieldCell endog); f3/f7 create instances; f4/f6/f8 remove instances; f10 ext writes γi,t,j,t _i,t,h_j,t (sheep/wolf endog) — all valid cross-agent effects r14 Information-access validation PASS every Decision-basis var is self-attribute or T3-authorized (grass at my patch; co-located sheep positions) r15 Input–output coverage (bidirectional) PASS every T2 “Input” var has a T6a entry; every T6a symbol is an exog T2 var; all outputs computable from T2 r16 Schedule coverage (bidirectional) PASS f1–f11 all appear in T7a; every T7a ID exists in T4 r17 Termination-indicator source PASS c1 uses St,WtS_t,W_t (T6b); c2 uses Wt,St,NmaxW_t,S_t,N_ (T2/T6b); c3 uses t (exempt) r18 Validation-object coverage PASS v1/v2→ℓ¯ts ^s_t; v3→(ST,WT)(S_T,W_T); v4→ ,WtS_t,W_t; v5→ ,te_i,t; all trace to T2/T6b r19 Data-reference resolution PASS T5 is empty (no stand-alone dataset); all T6a sources are Author; no empirical data references to resolve Summary: 19/19 PASS. Figure 6: Wolf stride-length selection (default model) — VISA reproduction evidence. NetLogo 6.4 reference (solid) vs. the Python re-implementation generated from the VISA specification (dashed), each a mean over 3 runs/seeds. Both platforms reproduce the causal reversal: penalty ON → wolves evolve a shorter stride; penalty OFF → a longer one. (T8 v1/v2.) Figure 7: Sheep stride-length evolution (high-density sheep–grass subsystem) — VISA reproduction evidence. NetLogo 6.4 (solid) vs. VISA-Python (dashed). Both platforms reproduce the divergence: without the penalty, sheep stride climbs faster; with it, the cost caps the climb. (T8 v1.) Figure 8: Predator–prey oscillation (default model, penalty on, coexistence) — VISA reproduction evidence. The three populations—sheep (green), wolves (red), and grass/4 (brown)—are each plotted twice: the VISA-Python reproduction (solid) overlaid on the NetLogo 6.4 reference (dashed). Both platforms reproduce the same emergent dynamics—out-of-phase sheep–wolf–grass cycles with matching period and amplitude. (T8 v4.) Appendix C Model 3 — AgedCareContactModel (described; reproduction blocked) AnyLogic 8.9 model of an aged-care facility (contact-matrix generation). This is the expressiveness case: the specification captures a 29-type / 240-function industrial model in eight tables and passes 19/19 rules with no structural accommodation. Full reproduction is blocked by (1) the proprietary AnyLogic Pedestrian Library, which executes all movement and hence dominates the contact-matrix output, and (2) unavailable backing data; VISA makes both barriers explicit and localized rather than hidden. No figure (by design; see the paper). C.1 VISA Specification — AgedCareContactModel (Exp3) Model. Generating a Contact Matrix for Aged Care Settings in Australia: An Agent-Based Model Study [58] — an AnyLogic 8 agent-based model of an aged-care (nursing-home) facility that produces epidemiological contact matrices from fine-grained staff–resident and resident–resident proximity. The model and its backing data are released by the authors at https://github.com/BREATHE-UNSW/AgedCareContactMatrix. It was developed and documented following the ODD (+ODD+D) protocol; movement uses the Helbing–Molnár social-force pedestrian model [28]. Role in the experiment. This is the describe-only / expressiveness case (see the experiment README, Model 3). The goal is not to reproduce the model — it is to show that visa-author produces eight faithful tables capturing a large, real-world, industrially-authored ABM and that visa-check passes 19/19, and then to honestly document why full reproduction is blocked. That limit is itself a finding for the paper (see the Reproduction blocker section below). Modelling logic (what is — and is not — an agent). The agent taxonomy follows the model’s own semantics (per its paper), not the host platform’s object graph. The paper defines two agent populations — residents and staff — acting inside a physical facility. VISA therefore has four agent types: • Environment (Main) ℳM — the clock, shift roster, person/location registries, and the contact-matrix computation. It also owns the contact record store: a finalized proximity contact is data produced by the simulation, so it is an endogenous aggregate of the Environment, not an agent in its own right. The action of “recording a contact” is an Environment function, not a ContactRecord agent. • Floor Plan (Location) ℒL — the Space agent: a heterogeneous, functionally-typed room hierarchy that manages the spatial relationships among residents and staff and is the co-location substrate determining who can contact whom. • Resident ℛR and Staff S — the two decision-makers. Two things that the AnyLogic object graph exposes as separate classes are not agents: (i) Contact records are an action/output of contact detection, hence absorbed into the Environment (the matrix CtC_t and the record log); (i) reference data (the floor-plan registry, the staff activity-diary survey, the task templates, the shift roster) are datasets, hence described by T5 (Associated Data), not by a T1 agent row. This is the modelling-logic test of VISA: it asks what behaves, and only those things become agents. Authoring note (space). Like Exp1 (Rebellion) and Exp2 (Wolf Sheep), this model uses an explicit Space agent — but where theirs is a homogeneous toroidal grid that answers metric / patch-co-location queries, here space is a heterogeneous, functionally-typed floor plan (rooms have different purposes, and which room a person is in determines whom they can contact). Co-location in typed rooms is load-bearing for the output, so the Location hierarchy is the Space agent set ℒL. Authoring note (abstraction). The model’s raw source contains roughly 240 functions across roughly 29 object types. These are collapsed to the 14 behavioural-level functions that carry model semantics. Platform plumbing (source / go-to / wait / sink navigation blocks, process-flow primitives, process tokens, and the per-care-level activity sub-controllers) are absorbed into their owners’ schedule functions (they are embedded sub-objects, not independent decision-makers). Every retained function is traceable to a named source routine. Notation. Sets calligraphic: ℳM (Main/Environment), ℒL (Floor Plan/Space), ℛR (Resident), S (Staff). Instances lowercase + subscript (ri,sj,ℓkr_i,s_j, _k). Exogenous params uppercase (IR,ρ,δ,Δt,T1,T2,T3,M1,M2,M3I_R,ρ,δ, t,T_1,T_2,T_3,M_1,M_2,M_3); endogenous lowercase + subscript or symbol with a time index (τt _t time-of-day, σt _t current shift, CtC_t contact matrix, positions (xi,tr,yi,tr)(x^r_i,t,y^r_i,t)). The time index t (in seconds) marks a variable as endogenous and may be suppressed in prose for readability. C.1.1 T1 — Agent Name Set Instances Category Description Quantity Environment (Main) ℳM m Environment Clock, shift roster, location/person registries; contact detection policy; contact-matrix computation and record store; output emission Nℳ=1N_M=1 Floor Plan (Location) ℒL ℓ1,ℓ2,… _1, _2,… Space Heterogeneous, typed room hierarchy bound to the floor plan; maintains person–room membership and is the co-location substrate determining who can contact whom NℒN_L (fixed; loaded from d1) Resident ℛR r1,r2,…r_1,r_2,… Decision-maker Aged-care resident; care-level-stratified daily activity schedule; proximity contacts tracked nℛn_R (variable; set by IRI_R, see T6a) Staff S s1,s2,…s_1,s_2,… Decision-maker Care staff; shift-based, priority-driven work schedule over the daily task set; proximity contacts tracked n_S (variable; injected per shift, departs at shift end) Notes. • Why ContactRecord and ReferenceData are not agents. A finalized proximity contact is a datum the simulation emits — it is produced by an Environment function (f4) and stored as the matrix CtC_t plus a record log (T6b), not inhabited by an agent. The backing lookups (floor-plan registry, staff activity-diary survey, task templates, shift roster) are datasets and are recorded in T5. This keeps T1 to the four things that actually behave. • Consolidation of the source types into 4 VISA agent sets. The 8 Location subtypes (Wing/Bedroom/Bathroom/Bedspace/Dining/Communal/Staff_Room/Transit) are one Space set ℒL (distinguished by location type). The activity sub-controllers and process tokens are embedded sub-objects of ℛR/S, not independent agent sets. • Population dynamics (→ r8). Variable (n): ℛR created by f5 (init) and S created by f3 (inject at each shift boundary) and removed by f13 (depart at shift end); each owns a creation/removal function. Fixed (N): ℳM (=1=1) and ℒL (loaded from d1) have no create/remove functions. C.1.2 T2 — Variable Variable Symbol Type Data type Value Unit Description Environment ℳM Initial # residents IRI_R Exog.-homo. Integer Input — facility population Contact-policy range ρ Exog.-homo. Float Input m proximity threshold for a contact Contact duration threshold δ Exog.-homo. Float Input s min co-presence for a contact Time step Δt t Exog.-homo. Float Input s integration step Simulation start time — Exog.-homo. Float Input min clock value at t=0t=0 Shift start times T1,T2,T3T_1,T_2,T_3 Exog.-homo. Float Input min start of each of the three daily shifts Staff per shift M1,M2,M3M_1,M_2,M_3 Exog.-homo. Integer Input — staff injected at each shift boundary Staff per wing — Exog.-homo. Integer Input — staff allocated per wing Queue timeout — Exog.-homo. Float Input min stale-task escalation limit Second of day τt _t Endog. Float f2 s model clock Current shift σt _t Endog. Integer f3 — ∈1,2,3∈\1,2,3\ Contact matrix CtC_t Endog. Matrix[Integer] f4 contacts role×role aggregated contact counts Floor Plan ℒL (Space) Location name / node id — Exog.-hetero. String f5 — floor-plan node identifier Location type — Exog.-hetero. Enum f5 — bedroom / bathroom / dining / communal / staff room / … Geometry / polygon — Exog.-hetero. Polygon f5 m room footprint (from d1) Associated wing / bed — Exog.-hetero. Location ref f5 — structural links Occupancy — Endog. List[ℛ∪R∪S] f6; f10 — persons currently in this room Resident ℛR Care level cic_i Exog.-hetero. Enumhigh,med,low f5 — drives the care-level activity schedule Mobility — Exog.-hetero. Enum f5 — tied to care level (high→ mobility) Allocated bed / bath / wing — Exog.-hetero. Location ref f5 — set at init Position (xi,tr,yi,tr)(x^r_i,t,y^r_i,t) Endog. Float×2 f6 m continuous-space pedestrian position Current activity / command — Endog.-dec. Enummove,wait+ref f6 — selected from the care-level schedule (d2) Sleep / assisted / med. flags — Endog. Boolean f6 — activity-driven state Persons in range — Endog. List[ℛ∪R∪S] f7 — peers within ρ this step Open contact sessions — Endog. List[(peer, dur)] f7; f8 — transient sessions being aged Staff S Working / depart flags — Endog. Boolean f9; f13 — on-shift / leaving Current working wing — Endog. Wing ref f10 — area of responsibility Task / priority state — Endog.-dec. Enum+priority f10 — current task from the priority queue (d2) Residents responsible — Endog. List[ℛR] f9 — residents in the assigned wing Position (xj,ts,yj,ts)(x^s_j,t,y^s_j,t) Endog. Float×2 f10 m continuous-space pedestrian position Persons in range — Endog. List[ℛ∪R∪S] f11 — peers within ρ this step Open contact sessions — Endog. List[(peer, dur)] f11; f12 — transient sessions being aged Transient quantities (not stored): the contact-verdict flag isContact:=duration≥δisContact:=duration≥δ is computed inside the aging step (f8/f12) when a session closes, then handed to the Environment (f4). The activity / task templates themselves are datasets (d2), read by the decision-makers, not stored as agent state. C.1.3 T3 — Sensing Spatial modality. A person “senses” another iff the continuous-space Euclidean distance between their positions is ≤ρ≤ρ (contact-policy range). Co-location in a typed room is derived from position. Rows = observers; columns = observed. Observer ℳM ℒL ℛR S ℳM (Env) ∅ occupancy ∗* ∗* ℒL (Floor) ∅ ∅ ∅ ∅ ℛR (Resident) τt,σt _t, _t ∅ pospos pospos S (Staff) τt,σt _t, _t ∅ pospos pospos Reading the matrix. pospos denotes “observes positions within radius ρ” — the proximity query that drives contact detection; it is symmetric, so ℛR senses S and vice versa. The ℛR and S diagonals carry pospos: a resident (resp. staff) observes the positions of other residents (resp. staff) within ρ; self-state is implicit. The Environment observes everything (it owns the global registries and computes the matrix). ℒL is a spatial carrier with no sensing of its own; room membership is derived from person positions, not sensed by the room. The activity/task templates (d2) are read once at init by ℛR/S. C.1.4 T4 — Internal Function Complex updates are given as numbered equations below the table. The “External effect: movement delegated to Pedestrian Library” flag marks the proprietary movement that is the reproduction blocker (see the Reproduction blocker section below). ID Function Method Decision basis Self-state update External effect Ref. Environment ℳM f1 initialise_model Setup d1 (floor plan), IRI_R, d2 (schedules) τ,στ,σ, care-level map create ℒL, ℛR, initial S [58] f2 advance_clock Time integration Δt t τt _t via (19) — — f3 manage_shift Event-driven τt;T1,T2,T3 _t;\,T_1,T_2,T_3 σt _t, shift-boundary flags create S (shift start); remove S via f13 (shift end) [58] f4 aggregate_contacts Aggregation closed sessions (all persons) CtC_t via (21) append finalized records to the contact log (T6b) [58] Resident ℛR f5 initialise_resident Setup d1 (allocated room), care level cic_i, mobility, allocations — [58] f6 advance_resident_activity Statechart + pedestrian care-level schedule (d2); τt _t position, activity, sleep/assisted/med. flags movement delegated to Pedestrian Library; update ℒL occupancy [28] f7 detect_contacts Proximity query all-person positions; ρ persons-in-range, open sessions — (opens transient session) [58] f8 age_contacts Duration update Δt,δ t,\,δ open-session duration; close + verdict via (20) — [58] Staff S f9 initialise_staff Setup σt,ρ _t,\,ρ; assigned wing working flag, wing, residents-responsible — [58] f10 advance_staff_activity Priority statechart + pedestrian task set (d2); τt _t; queue timeout position, task/priority state, working wing movement delegated to Pedestrian Library; update ℒL occupancy [28] f11 detect_contacts Proximity query all-person positions; ρ persons-in-range, open sessions — (opens transient session) [58] f12 age_contacts Duration update Δt,δ t,\,δ open-session duration; close + verdict via (20) — [58] f13 depart_staff Event-driven shift end (τt _t) depart flag remove self from S [58] Floor Plan ℒL f5’ initialise_location Setup d1 (floor-plan registry) name, type, geometry, associations — [58] (The Location init is labelled f5′ to avoid colliding with the Resident init f5; it is a distinct function of a distinct agent type.) Behavioural equations. The clock and the contact aggregation are τt=τt−1+Δt(mod86400) _t= _t-1+ t 86400 (19) isContact:=duration≥δ,Ct[role(a),role(b)]+=[isContact]for each session closed at t.isContact:=duration≥δ, C_t[\,role(a),role(b)\,] +=1[isContact] each session closed at t. (20) Ct[i,j]=#closed contact sessions at ≤t:role(contacter)=i∧role(contactee)=j∧isContactC_t[i,j]=\#\closed contact sessions at ≤ t:role(contacter)=i\, \,role(contactee)=j\, \,isContact\ (21) Contact lifecycle (f7→ 8, mirrored by f11→ 12). Each step, a person queries peers within ρ (f7/f11); peers newly in range open a session recording onset time. Open sessions are aged each step (f8/f12: duration +=Δt+\!= t). When a peer leaves range, the session closes, the verdict (20) is evaluated, and the closed session is handed to the Environment. f4 (Environment) aggregates all freshly-closed sessions into the matrix CtC_t (21) and the record log (T6b). This is the epidemiological core; there is no separate “contact-record agent” — contacts are data produced by detection + aging and consumed by aggregation. C.1.5 T5 — Associated Data ID Name Type Temporal Collection Pre-processing Availability d1 Floor-plan / location registry Empirical Static model distribution geometry → typed nodes/polygons; assigned location type Unavailable (backing layout not distributed) d2 Activity schedules & task templates (resident care-level activities; staff daily tasks with durations) Empirical / Synthetic Daily cycle staff activity-diary survey + template objects mapped to statechart tasks; care-level stratification; priority assignment Unavailable (survey data collected for this study, not released) d3 Staff shift roster (shift starts, per-shift headcounts, wing assignments) Empirical Daily cycle facility parameters shift-boundary table Partial (scalar params in T6a; full roster unavailable) All three are marked Unavailable / Partial. The backing datasets were not distributed with the model and could not be located (the activity-diary survey was collected specifically for this study). This is reproduction blocker #2 (see below): the provenance chain is incomplete, so even the reproducible custom logic cannot be fully instantiated. The IDs d1–d3 nevertheless exist, so every empirical reference in T6a/T8 resolves to a T5 record (→ r19). C.1.6 T6 — Input/Output (a) Inputs Symbol Value / Distribution Data source Derivation Algorithm Ref. Environment ℳM IRI_R 60 Author Assumed — — ρ 1.5 or 3 (scenario) Author Assumed — — δ 3 s Author Assumed — — Δt t 1.0 s Author Direct — — sim start 6:15 Author Assumed — — T1,T2,T3T_1,T_2,T_3 6:45 / 14:30 / 22:25 d3 (partial) Assumed — — M1,M2,M3M_1,M_2,M_3 12 / 12 / 6 Author Assumed — — staff per wing 2 Author Assumed — — queue timeout 40 min Author Assumed — — floor plan (layout) d1 (unavailable) Estimated — — activity/task schedules (templates) d2 (unavailable) Estimated — — Resident ℛR care-level mix per facility (high/med/low) Author Assumed — — Staff S (init per shift) M1,M2,M3M_1,M_2,M_3 per wing Author Direct — — (b) Outputs ID Output Symbol Type Derivation Formula Freq. o1 Contact matrix C Matrix[Integer] Computed (21) −1-1 (terminal) o2 Contact-record log κ\κ\ Table Direct each closed session (contacter/contactee role, onset, duration, isContact) Δt t (streaming) C.1.7 T7 — Schedule (a) Execution Step Agent ID Function Exec. mode Condition 1 ℳM f2 advance_clock Synchronous (Δt t) every step 2 ℳM f3 manage_shift Event-driven (shift table) τt∈T1,T2,T3 _t∈\T_1,T_2,T_3\ 3 ℛR f5 initialise_resident Synchronous at init / on resident inject 4 ℛR f6 advance_resident_activity Composite: Sequential (ℛR) ⊕ Asynchronous (library; velocity, ρ) every step 4 ℛR f7 detect_contacts Composite: Sequential (ℛR) ⊕ Asynchronous (library) every step 4 ℛR f8 age_contacts Composite: Sequential (ℛR) ⊕ Asynchronous (library) every step 5 S f9 initialise_staff Event-driven (shift table) at shift start / end 5 S f13 depart_staff Event-driven (shift table) at shift end 6 S f10 advance_staff_activity Composite: Sequential (S) ⊕ Asynchronous (library; velocity, ρ) every step 6 S f11 detect_contacts Composite: Sequential (S) ⊕ Asynchronous (library) every step 6 S f12 age_contacts Composite: Sequential (S) ⊕ Asynchronous (library) every step 7 ℳM f4 aggregate_contacts Synchronous every step (after contact cycles) 8 ℒL f5′ initialise_location Synchronous at init only Exec.mode note. The agent-level updates — clock, activity/task selection, contact detection/aging — are integrated synchronously (breed-sequential: environment clock → residents → staff, each iterated per 1-second step, then f4 aggregates contacts). The pedestrian movement (position updates for f6/f10) is integrated by the proprietary AnyLogic Pedestrian Library in a continuous-time Asynchronous sub-step with no open specification. Per VISA, this is a composite mode (Sequential ⊕ Asynchronous); composites are built from base modes, and the proprietary sub-step is the reproduction blocker (see below). (b) Termination ID Indicator Condition Description Value source/ref Termination logic c1 τt _t τt≥ _t≥ simulation horizon Configured run length (e.g. 24 h) reached Author assumed Stop when c1c_1; f4 then emits C + κ\κ\ C.1.8 T8 — Validation Validation uses the HAV framework at three levels. Because full reproduction is blocked (proprietary library + unavailable data), every entry’s empirical status is Blocked; the table remains structurally valid — each indicator traces to a T2/T6b quantity, and each benchmark traces to a T5 record — it simply cannot be executed. ID Level Hypothesis Indicator Benchmark Status v1 Output C reproduces the empirical aged-care contact pattern by role×role C[i,j]C[i,j] cells source-paper matrices (d-class) Blocked v2 Model Staff–resident contacts concentrate during care activities (meals, meds) and in care zones temporal/spatial distribution of staff–resident contacts qualitative expectation (paper) Blocked v3 Output Contact-duration distribution is consistent with the ≥δ≥δ definition duration histogram constructed (threshold δ) Blocked v4 Model Total contacts scale with staff:resident ratio and population density #\#\contacts\ vs IR,MshiftI_R,M_shift sensitivity expectation (paper) Blocked v5 Output Matrices differ substantially between ρ=1.5ρ=1.5 m and ρ=3.0ρ=3.0 m C1.5C_1.5 vs C3.0C_3.0 known sensitivity (paper) Blocked C.1.9 Consistency check (19 rules) Within-table (r1–r4) and cross-table (r5–r19), per the revised VISA rule set. Rule Res. Note r1 Variable-type coverage & time-indexing PASS every T2 variable carries one of the four leaf types; every endogenous variable carries the time index t (τt,σt,Ct _t, _t,C_t, resident/staff positions, occupancy, open sessions) r2 Function-ID uniqueness PASS f1–f4, f5–f8, f9–f13, f5′ are unique within their owners; every f-ID in T2’s Value column exists in T4 r3 Function productivity PASS every function writes ≥ 1 endogenous variable or creates/removes an instance (f1 setup; f2 τt _t; f3 σt _t+create/remove; f4 CtC_t; f5 allocations; f6 position/flags; f7 persons-in-range/sessions; f8 session duration; f9–f12 likewise; f13 remove) r4 Step–Exec.mode consistency PASS within each T7a step the agent-update mode is consistent; the proprietary Asynchronous sub-step is an explicit composite component, not a contradictory base mode r5 Same-type (peer) sensing PASS ℛR and S diagonals state pospos (peer positions within ρ); single-instance types (ℳ,ℒM,L) have ∅ diagonals; self-observation is implicit r6 Passive-agent implications PASS no Passive agents (ContactRecord/ReferenceData were removed: records→ aggregate, data→ 5) r7 Observer-row completeness PASS every active agent (ℳ,ℒ,ℛ,M,L,R,S) has exactly one T3 row r8 Population-dynamics consistency PASS variable sets ℛ,R,S each own a creation and a removal function (f5 / f9-create + f13); fixed sets ℳ,ℒM,L own none r9 Active-agent function coverage PASS every non-Passive agent owns ≥ 1 function — ℳM(f1–f4), ℛR(f5–f8), S(f9–f13), ℒL(f5′) r10 Variable observability PASS every variable is self-read or T3-authorized (peer positions via pospos within ρ; globals τt,σt _t, _t; room occupancy derived from position; activity/task templates read from d2 at init) r11 Endogenous-variable completeness PASS every endogenous variable is written by ≥ 1 existing f-ID — τt _t(f2), σt _t(f3), CtC_t(f4), allocations(f5), resident position/flags(f6), sessions(f7–f8), staff state(f9–f12), occupancy(f6/f10) r12 Self-state-update validity PASS every Self-state target is endogenous of the owning agent r13 External-effect validity PASS every External Effect is a valid instance create (ℒ,ℛ,L,R,S), remove (S via f13), occupancy update (ℒL), or output emission r14 Information-access validation PASS every Decision-basis variable is a self-attribute or T3-authorized (peer positions within ρ; co-room occupancy; d2 templates at init) r15 Input–output coverage (bidirectional) PASS every T2 Input variable has a T6a entry; every T6a symbol is an exog T2 variable; outputs computable from T2 r16 Schedule coverage (bidirectional) PASS every T4 function appears in ≥ 1 T7a step; every T7a step’s function ID exists in T4 r17 Termination-indicator source PASS c1 references τt _t (T2) and triggers f4/o1,o2 (T6b) r18 Validation-object coverage PASS v1–v5 indicators (C, contact log, duration histogram, contact counts) all trace to T2/T6b r19 Data-reference resolution PASS d1 (floor plan), d2 (schedules), d3 (roster) all exist in T5; all T6a/T8 empirical references resolve to a d-ID or to Author Summary: 19/19 PASS. An 8-table specification authored from an external, independently-authored AnyLogic model — with no structural accommodation — passes all nineteen consistency rules. This is the expressiveness evidence for Model 3. C.1.10 Reproduction blocker visa-code is not invoked for this model and no reproduction is attempted. Two independent, structural barriers block the loop visa-code → reproduce: Blocker 1 — proprietary Pedestrian Library (the dominant barrier) All movement — both residents and staff — is executed by the AnyLogic Pedestrian Library, which implements the social-force model of [28]. The model’s own logic only emits movement commands (move to a destination node / wait / depart); the library decides the physics — priority-based pathfinding, congestion- and density-dependent velocity, continuous-space crowd navigation, collision avoidance. None of this is specified in the workspace or in any open document; it lives in the closed pedestrian-library component. Why this blocks reproduction. The model’s output — the contact matrix — is generated by contact detection, and contacts arise from co-location (who is within ρ of whom at each second). Co-location arises from movement. Reproducing only the model’s own command logic (captured in T1–T8) reproduces what each agent decides to do but not how it moves, hence not where agents co-locate, hence not the matrices. The output is dominated by the opaque library. Blocker 2 — unavailable backing data The model loads its floor plan (d1), activity/task schedules (d2), and shift roster (d3) from databases / hardcoded tables that were not distributed with the model and could not be located — the activity-diary survey was collected specifically for this study. Without them, even the reproducible custom logic cannot be fully instantiated (e.g. the location registry ℒL and the care-level activity schedules are empty). Why this is a finding, not a VISA failure VISA cleanly separates the two kinds of behaviour in this model: • (a) custom Java logic — activity scheduling, the priority staff task statechart, shift management, contact detection at ≤ρ≤ρ for ≥δ≥δ, matrix aggregation, I/O — fully captured in T1–T8 and reproducible; • (b) AnyLogic Pedestrian Library navigation — flagged in T4 (“movement delegated to Pedestrian Library”) and T7a (Asynchronous composite sub-step), not reproducible. By making (a) explicit and (b) a named, localized dependency, VISA exposes that the proprietary library is the real reproducibility barrier — a transparency contribution. A reader of the 8 tables can see exactly which parts of the model are open and which are not. This is precisely the expressiveness claim Model 3 was chosen to demonstrate: VISA scales to a large real-world ABM, faithfully, and honestly demarcates its own limit. Appendix D The three VISA skills The three LLM-executable skills that operationalize VISA — authoring, checking, and code generation. These are released as supplementary material and maintained on the companion GitHub repository. D.1 VISA Authoring Skill Purpose. Guide an LLM agent in constructing the eight VISA tables for an agent-based simulation (ABM) model, so the output is complete, internally consistent, and machine-parseable. This skill is the constructive counterpart to visa-check, which verifies the 19 consistency rules. D.1.1 When to invoke Invoke this skill when the user provides a model description (natural-language narrative, an ODD description, equations, or a reference implementation) and asks to produce / convert / document it as a VISA specification. D.1.2 Companion skill After authoring (or after each table), invoke visa-check to verify the 19 consistency rules. Author and check in tandem until all rules pass. D.1.3 Authoring pipeline (mandatory order) Build the tables in this order. Each table supplies identifiers that later tables cross-reference; producing them out of order creates dangling references. T1 Agent -> T2 Variable -> T3 Sensing -> T4 Internal Function -> T5 Associated Data -> T6 Input/Output -> T7 Schedule -> T8 Validation After you finish… The next tables can now safely reference… T2 every variable Symbol and its Type (exog/endog) T3 which (observer, observed) pairs exist and which variables each cell exposes T4 function IDs f1, f2, … (consumed by T2 Value, T7 schedule) T5 data IDs d1, d2, … (consumed by T6 Data source, T8 Benchmark data) T6a exogenous parameter values/distributions (consumed by T2 exogenous ”Input”) T6b output indicator symbols (consumed by T7b, T8) T7a the per-step execution loop; T7b termination indicators T8 (terminal; consumes T2 variables and T6b indicators as validation objects) D.1.4 Notation conventions (apply in every table) Element Convention Example Agent instance lowercase italic + subscript viv_i the i-th vendor Exogenous param / aggregate uppercase italic N population, D demand, T horizon Endogenous variable lowercase italic + subscript + time index t qi,tq_i,t order qty, pi,tp_i,t price, xi,tx_i,t position Vector / matrix boldface i,ts_i,t sales history, AtA_t adjacency Reserved indices i,j,ki,j,k instances; t time step — Fixed count N_X N=1N_W=1 Variable count n_X n_V (vendors enter/exit) Optimal value superscript ∗* q∗q^* Temporal lag subscript t−1t-1 si,t−1s_i,t-1 Time index on endogenous variables (r1). Every endogenous variable evolves over the simulation, so its Symbol in T2 carries the time index $t$ (e.g. $x_i,t$, $p_i,t$); exogenous variables do not. The index is written explicitly in T2 (where each variable is defined) and may be suppressed in T4 cells, equations, and prose for readability. D.1.5 Identifier conventions (stable IDs, reusable across tables) Prefix Meaning Lives in d associated data record (d1, d2, …) T5 c termination condition (c1, c2, …) T7b v validation entry (v1, v2, …) T8 r consistency rule (r1–r19) rules table (handled by visa-check) D.1.6 Table-by-table schema T1 — Agent Enumerates the model’s ontology: agent types, roles, counts. Column Required content Set Calligraphic symbol (ℰ,,,,,…E,S,W,V,C,…) Instances Instance symbol(s), e.g. e, v1,v2,…v_1,v_2,… Category One of: Environment | Space | Decision-maker | Passive (definitions below) Description One-line role Quantity N=kN_X=k (fixed) or n_X (variable) Category definitions (controlled vocabulary): - Environment — manages the lifecycle of other agent instances (creation, removal, ordering) and computes model-level statistics / output aggregates (e.g., a mean price, a Gini coefficient). Parameters and state that belong to a specific decision-maker are attributed to that decision-maker, not dumped on the Environment. - Space — an active agent that owns the spatial/topological geometry of the world (dimensions, boundary/wrap conditions, room layout) and maintains the spatial or topological relationships among the currently-alive agents (a grid answering vision-range queries, a network exposing neighbors). It typically owns a spatial-query function and is not a passive container. A metric that belongs to a sensing decision-maker (e.g., a vision radius) is attributed to that decision-maker, not to the Space agent — the Space agent only reads it as a query argument. Model space implicitly only when there is no spatial interaction at all. - Decision-maker — executes behavioral rules, makes autonomous choices from internal state + sensed info. - Passive — static information carrier; no autonomous behavior. (Implications enforced by r6: no endogenous variables, column-only in T3, no functions in T4.) What is — and is not — an agent (modeling logic). Only things that behave autonomously become agents; the host platform’s object graph is not the taxonomy. Two things that platform code often exposes as separate classes are not agents: (i) a simulation output datum (a finalized contact record, an emitted event, a logged transaction) is data produced by a function — model it as an Environment aggregate and/or a T6b output, not a T1 agent; (i) reference / lookup data (a floor-plan registry, a survey, a parameter table, a template library) is a dataset — model it in T5 (Associated Data), not as a Passive agent. Likewise, a parameter read by several decision-maker types is declared on each of those types in T2 (its value listed once in T6a), never parked in the Environment. Quantity rule: N = predetermined fixed count; n = count that may change during the run (entry/exit). T2 — Variable Complete state-space specification: every variable of every agent type. Column Required content Symbol Notation per conventions above Type One of four leaf types (see below) Data Type Programming type: Integer, Float, Boolean, List[Integer], Matrix[Integer], … Value Input (exogenous → ref T6a) or function ID(s) f4, f1, f2 (endogenous → ref T4) Unit Physical/monetary unit, or -- if dimensionless Desc. Short description Group rows by agent type using headers (matching T1 order). Type — controlled vocabulary (two-level): - Exogenous (value supplied from outside; no internal function writes it) - Exog.-homo. — identical across all instances - Exog.-hetero. — varies per instance (e.g., drawn from a distribution) - Endogenous (value set within the model by a function) - Endog.-dec. — directly set by the agent’s own decision function - Endog. (non-decision) — computed consequence, not directly controlled by a decision Single-instance relaxation (notation, not a rule): for any agent type with N=1N=1, the homo/hetero distinction is vacuous; its exogenous variables need not specify it. This is a notation convenience, not a consistency rule. Value provenance: exogenous → Input (T6a gives the value); endogenous → the f-ID(s) that compute it. T3 — Sensing Information-access matrix: which observer reads which variables from which observed agent. • Rows = observer agents (every non-Passive type, including Environment and Space). • Columns = observed agents (all types). Split with a vertical bar: active agents (Env/Space/Decision-maker) left, Passive agents right. Passive agents are columns only (never rows). • Cell values (controlled notation): – * — access to all attributes of the observed agent (off-diagonal only) – ∅ — no access – list of specific variable Symbols, e.g. p_i, _i, w_i – Diagonal (an instance observing other instances of its own type): list the observable peer attributes directly, e.g. p_j (no braces); use ∅ if same-type agents observe nothing of each other * Every agent reads its own full state by default — self-observation is implicit and never appears on the diagonal, which lists only peer attributes * ∅ for any single-instance type (N=1N=1), since it has no peers Space agents appear as columns too: they mediate topology (e.g., a vendor reads the adjacency matrix AtA_t from the Space agent to find its neighbors). T4 — Internal Function Behavioral logic of every agent: what each function reads, updates, and affects externally. Column Required content Function snake_case name, e.g. decide_order Method Short method label, e.g. Optimization, Mean, Multinomial logit, Preferential attachment, Conditional Decision Basis Variables consumed (from T2 / sensed from T3). Must be self-attributes or T3-authorized observations (r14). Self-state Update Endogenous variables of this agent modified, with assignment, e.g. qi←q_i← Eq. (3). Must be endogenous (r12). External Effect Endogenous variables of other agents modified, or ---. Must be endogenous vars of other agents (r13), or an instance create/remove of a variable-quantity type (r8); never another’s exogenous var. Ref. ... motivating the Method, or --- for purely mechanical computation (arithmetic, mean, transfer). Group rows by agent type. Every function exists to update endogenous variables — its own (Self-state Update) or others’ (External Effect). Keep cells concise — formalize, then reference. This is why symbols are defined first. If a Self-state / External-effect update is more than a short phrase, write it as a numbered equation below the table and put only the written variables + an equation reference in the cell (e.g. $x_i,t, y_i,t$ via Eq.~(3)). Avoid inventing inline shorthand (e.g. ad-hoc “Rule A”) that is never defined; every piece of logic must be either a named, defined equation or a direct assignment. The Self-state Update / External Effect columns then record which endogenous variable is written and which equation governs it — not prose. Table presentation. Within any table partitioned by agent (T2, T4, T6a), precede each agent’s block with a full-width separator row (a horizontal rule above, then the bold agent name) so the partition is visually unambiguous. Allocate column widths by content — wide columns for prose (Description, Decision basis, updates), narrow for symbols/units/flags — rather than dividing evenly. T5 — Associated Data Complete provenance chain for every external data source. Column Controlled vocabulary / content Title Descriptive name Type Empirical | Literature | Generated Temporal Static | Dynamic Source Named source + year, or Author Collection Survey | Administrative | Sensor | Experimental | Computational Pre-processing None | Selected | Aggregated | Transformed #Rec. Record count Avail. Open | Restricted | Private Definitions (use precisely): - Type: Empirical = real-world observation/measurement; Literature = peer-reviewed values/datasets; Generated = synthetic / sampled / auxiliary-sim output. - Temporal: Static = loaded once; Dynamic = reloaded/updated during the run. - Collection: Survey, Administrative (institutional/gov records), Sensor (automated measurement), Experimental (controlled experiment), Computational (algorithm/auxiliary sim). - Pre-processing: None (raw), Selected (subset extraction), Aggregated (summary stats / coarser grains), Transformed (math/type/normalization, same record count). - Availability: Open / Restricted (conditional) / Private. T6 — Input and Output Two sub-tables. (a) Input — every exogenous parameter Column Content Value / Distribution Scalar, tuple, or distribution (e.g. U(Ma,Mb)U(M_a,M_b)) Data source d1, d2, … (ref T5) or Author Derivation Direct | Estimated | Computed | Assumed (definitions below) Algorithm Named procedure (e.g. maximum likelihood estimation) or paper-defined algorithm (e.g. Alg. 1); --- if Derivation is Direct/Assumed Ref. ... motivating the Algorithm, or --- Derivation — controlled vocabulary: - Direct — value taken verbatim from the data source, no processing. - Estimated — value or distribution parameters statistically inferred from data (fitting, mean/variance estimation). - Computed — value produced by a deterministic or stochastic procedure on known quantities (formula, randomized construction), without statistical inference. - Assumed — fixed by model design / expert judgment / literature; not from the data source. Group rows by agent type (matching T1/T2 order). (b) Output — every output indicator Column Content Indicator Descriptive name Formula Computation from T2 variables Data Type Reuses T2 type vocabulary (Integer, Float, List[Integer], …) Unit Unit or -- Frequency Integer k≥1k≥ 1 (sample every k steps; k=1k=1 = every step) or -1 (terminal step only) Desc. Short description T7 — Schedule Two sub-tables. (a) Execution schedule — the per-step loop Column Content Agent Agent-type Set acting ID Function ID from T4 (f1, …) Function Function name (mirrors T4) Exec. mode One of four base modes (+ optional inline parameters); see below Condition Trigger text (e.g. Every step, Only when a new vendor is added) Exec. mode — controlled vocabulary (four base modes): - Synchronous — all instances observe start-of-step state, update simultaneously (lockstep). - Sequential — instances act one at a time in a fixed deterministic order; later instances see earlier updates. - Random-order — as Sequential, but order uniformly randomized and reshuffled each step. - Asynchronous — not synchronized to the global step; event/time-driven activation. Mode-specific parameters are appended in parentheses, e.g. Sequential (by $w_i$, descending), Asynchronous (Poisson, $λ$). Conditional activation is not a mode — it goes in the Condition column. Staged execution (sense→ → sub-phases) is a composite built from the four modes, used only to rule out within-step information contamination. r4 constraint: all functions sharing a Step must share the same Exec. mode. (b) Termination conditions Column Content Indicator A T2 variable or T6b output indicator (r17) Condition Predicate on the indicator, e.g. t≥1000t≥ 1000 Description Plain-language meaning Value Source/Ref Where the threshold comes from (e.g. Author Assumed) Termination logic multirow combining all rows, e.g. Stop when c1\lorc2c1 lorc2 Initial values are not part of this loop — they are exogenous inputs via T6a. T8 — Validation Credibility framework. Instantiates the HAV (Hierarchical ABM Validation) framework: three levels, data-grounded vs non-data-grounded methods. Column Content Validation object What is being validated (an agent behavior, a structural mechanism, an aggregate output) Benchmark data Empirical reference (ref a d-ID from T5 where applicable) or a theoretical expectation Method Named statistical/theoretical method, e.g. K-S test, Moran’s I, Regression Indicator Test statistic computed Passing cond. Concrete accept criterion, e.g. p>0.05p>0.05 Ref ... for prior work using the same method, or --- Group rows into three multicolumn level groups (matching HAV hierarchy): - Agent level — individual agent behavior. - Model level — structural mechanisms. - Output level — aggregate results. Validation objects must be expressed as T2 variables or T6b outputs (r18); the Indicator column holds the test statistic, which is computed during validation and is not itself a model variable. Empirical benchmarks must resolve to a T5 entry (r19). Modelers are encouraged to add rows for more comprehensive validation. D.1.7 Output format • Emit each table as LaTeX (tabular/tabularx/tabular*) consistent with the manuscript style, OR as structured Markdown if the user wants a draft. • Preserve all IDs and cross-references (T2 Value → T4 f-IDs; T6a Data source → T5 d-IDs; T7a ID → T4; T7b/T8 indicators → T2/T6b). • After emitting, recommend running ‘visa-check‘ and list which rules are most likely at risk given what was just authored. D.1.8 Common authoring pitfalls 1. Forgetting to give a Passive agent’s variables in T2 — they may have exogenous variables but no endogenous ones (r6). 2. Listing an exogenous variable in T4 Self-state Update (violates r12). 3. A T4 function reading a variable the agent cannot observe in T3 (violates r14). 4. An endogenous variable in T2 whose Value column references no function, or references a non-existent f-ID (violates r11 — orphaned or dangling). 5. A function in T4 that never appears in T7a, or a T7a row citing a function not in T4 (violates r16 — unscheduled or phantom). 6. A Decision-maker agent in T1 with no function in T4 (violates r9). 7. A T6a symbol with no matching exogenous variable in T2, or a T2 “Input” variable with no T6a entry (violates r15). 8. A function that reads inputs but modifies no variable (violates r3 — unproductive). 9. An agent marked with variable quantity (n) but no create/remove function, or a fixed-quantity (N) agent with one (violates r8). 10. An empirical data reference in T6a or T8 that points to no T5 record (violates r19). D.2 VISA Checking Skill Purpose. Verify that a set of eight VISA tables satisfies the 19 consistency rules. For each rule, report pass/fail, the specific cells implicated in any violation, and a concrete suggested fix. Turns the rules from a manual checklist into an executable validator. D.2.1 When to invoke Invoke this skill when the user asks to validate / check / verify a VISA specification (complete or partial), or right after visa-author finishes a table. D.2.2 Inputs The eight tables (T1–T8) in any readable form (LaTeX, Markdown, or structured text). Partial specifications are allowed — rules whose required tables are absent are reported as BLOCKED (pending input) rather than failed. D.2.3 Output format VISA CONSISTENCY REPORT ======================= Within-table rules r1 [PASS | FAIL | BLOCKED] <one-line summary> (if FAIL) cells: ... | fix: ... ... Cross-table rules r5 ... ... Summary: X/19 PASS, Y FAIL, Z BLOCKED. For each FAIL, name the table, the row/cell, and a one-sentence fix. D.2.4 Within-table rules r1 — Variable-type coverage and time-indexing (T2) Inspect: every row of T2. Pass: each variable’s Type is one of the four leaf types Exog.-homo. | Exog.-hetero. | Endog.-dec. | Endog. (non-decision). No blank / top-only / free-text Type. In addition, every endogenous variable’s Symbol carries the time index $t$ (e.g. $x_i,t$, $p_i,t$), since it evolves over the simulation; exogenous variables do not. (The index may be suppressed in T4 cells, equations, and prose for readability, but must appear on each endogenous symbol in T2.) Fix: assign the correct leaf type. Recall the two-level test: (1) can an internal function write this variable? No → Exogenous; Yes → Endogenous. (2a) Exogenous: same for all instances → homo, else hetero. (2b) Endogenous: directly set by a decision → dec, else non-decision. Then append the time index $t$ to the Symbol of every endogenous variable that lacks it. r2 — Function-ID uniqueness (T4) Inspect: T4 ID column. Pass: all f-IDs in T4 are unique. Fix: remove/renumber duplicates. r3 — Function productivity (T4) Inspect: every T4 function’s Self-state Update and External Effect columns. Pass: each function lists at least one entry across the two columns — it modifies ≥ 1 endogenous variable (own or another’s) or creates/removes an instance. A function that reads inputs but writes nothing fails. Fix: add the missing write, or remove the function if it is redundant. r4 — Step–Exec. mode consistency (T7a) Inspect: T7a rows grouped by Step number. Pass: all rows sharing a Step number have the same Exec. mode; functions that must execute simultaneously share a Step. Fix: either move the mismatched function to its own Step, or align the Exec. mode. D.2.5 Cross-table rules r5 — Same-type (peer) sensing (T1 → T3) Inspect: T3 diagonal cells, cross-referenced with T1 Quantity. Pass: every agent type with variable quantity n>1n>1 records on the diagonal the attributes its instances observe of one another — the peer set ($ $ if they observe nothing of each other); a single-instance type (N=1N=1) has no peers and its diagonal is $ $. Self-observation is implicit (every agent reads its own full state) and is never recorded in a T3 cell. Fix: for each multi-instance type, state the peer-observed attributes on the diagonal (or $ $); for single-instance types, set the diagonal to $ $. r6 — Passive agent implications (T1 → T2, T3, T4) Inspect: every agent type whose T1 Category is Passive. Pass: for each Passive type — (i) it has no endogenous variables in T2; (i) it appears only as a column (right of the |) in T3, never as a row; (i) it has no functions in T4. Fix: if a Passive agent has endogenous vars/functions, reclassify it as Decision-maker in T1, or remove the offending entries. r7 — Observer row completeness (T1 → T3) Inspect: every non-Passive agent type in T1 vs. T3 rows. Pass: each non-Passive type has exactly one row in T3; Passive types have no rows. Fix: add the missing row, or remove a spurious Passive row. r8 — Population-dynamics consistency (T1 → T2, T4) Inspect: each T1 agent type’s Quantity (N vs n), its T2 count variable, and T4 functions. Pass: a type whose Quantity is variable (n) is created or removed by ≥ 1 T4 function (its count variable is endogenous, written by that function); a type whose Quantity is fixed (N) has no function that creates or removes its instances. Fix: add the missing entry/exit function, or correct the Quantity to N if the population is in fact fixed. r9 — Active-agent function coverage (T1 → T4) Inspect: every non-Passive agent type in T1 vs. T4 ownership. Pass: each active agent type owns ≥ 1 internal function in T4 (and therefore appears in T7a). Fix: add a function for the agent, or reconsider whether the agent is genuinely active (a static topology with no behavior may be Passive). r10 — Variable observability (T2 → T3) Inspect: every variable in T2; check whether it appears in at least one T3 cell (as itself, or covered by *). Pass: each variable is observable in ≥ 1 T3 cell, except variables never accessed by any function (verify against T4 Decision Basis). Endogenous-only/internal bookkeeping variables that no function reads from another agent are exempt. Fix: add the variable to the appropriate T3 cell, or confirm it is genuinely never sensed. r11 — Endogenous variable completeness (T2 → T4) Inspect: every endogenous variable in T2; check T2 Value column references ≥ 1 function. Pass: each endogenous variable is updated by at least one T4 function whose f-ID is listed in the Value column and exists in T4 (no dangling references). A variable may be updated by multiple functions. Fix: either assign the responsible f-ID(s) in T2 and ensure they exist in T4, or add the missing function in T4. r12 — Self-state update validity (T2 → T4) Inspect: every T4 Self-state Update entry. Pass: all variables listed are endogenous variables of that same agent (per T2). Fix: remove exogenous variables from Self-state Update; if a function truly needs to write an exogenous value, reclassify the variable as endogenous. r13 — External effect validity (T2 → T4) Inspect: every T4 External Effect entry. Pass: each entry is either (i) an endogenous variable of another agent (per T2), or (i) an instance creation/removal of a variable-quantity type (per r8). Modifying another agent’s exogenous variable is forbidden. Fix: remove the offending external write, reclassify the target as endogenous, or re-express a forbidden write as a legitimate instance operation. r14 — Information access validation (T3 → T4) Inspect: every T4 function’s Decision Basis variables. Pass: each Decision Basis variable is either (i) an attribute of the agent itself, or (i) a variable the agent is authorized to observe in T3 (in the cell for that observer/observed pair). Fix: remove the unobservable variable from Decision Basis, or grant access in the relevant T3 cell. r15 — Input–output coverage (T6 ↔ T2) Inspect: T6a Input symbols vs. T2 exogenous variables marked Input; T6b Output formulas vs. T2 variables. Pass: (a) every T6a Input symbol corresponds to an exogenous variable in T2; (b) every T2 variable marked Input has a matching T6a entry (no exogenous variable left without a value — an unsupplied input is a reproduction blocker); (c) every T6b Output indicator is computable from T2 variables. Fix: add the missing T2 variable or T6a entry, or remove the orphaned entry; ensure input symbols point only to exogenous vars. r16 — Schedule coverage (T7 ↔ T4) Inspect: every T4 function ID vs. T7a ID column, and vice versa. Pass: every function in T4 appears at least once in T7a, and every function ID in T7a exists in T4. A function may be scheduled multiple times; none may be unscheduled or phantom. Fix: add the missing function to T7a, or remove/correct a phantom T7a row. r17 — Termination indicator source (T7b → T2, T6) Inspect: every indicator in T7b’s Indicator column. Pass: each is either a T2 variable or a T6b output indicator. The global time index $t$ is always available and need not be declared. Fix: add the indicator to T2 or T6b, or correct the T7b reference. r18 — Validation-object coverage (T8 → T2, T6) Inspect: every T8 Validation object (the quantity submitted to validation). Pass: each validation object is expressed in terms of T2 variables or T6b output indicators. The T8 Indicator column holds the test statistic, which is computed during validation and is not itself a model variable (so it is not checked here). Fix: re-express the validation object using T2/T6b quantities, or add the missing variable/output. r19 — Data-reference resolution (T8, T6a → T5) Inspect: every empirical data reference in T8 (Benchmark data) and in T6a (Data source). Pass: each referenced d-ID has a corresponding T5 entry. References marked Author (T6a) and purely theoretical benchmarks (T8) are exempt. Fix: add the data record to T5, or change the reference to Author/theoretical. D.2.6 Checking heuristics • Build a symbol index first. From T2 collect every (Symbol, agent, Type). From T4 collect every (f-ID, owner agent). From T5 collect every d-ID. From T6b collect every output symbol. These indices make r2, r11–r15, r17–r19 mechanical lookups. • Check dependency order. If T4 is missing, r2/r3/r11/r12/r13/r14/r16 are BLOCKED. Report BLOCKED, do not guess. • Be specific. Always name the exact cell (e.g., “T2 row Vendor → q_i, Value column”) so the modeler can fix it directly. • Suggest, don’t rewrite. Propose the minimal fix; let the modeler accept it. D.2.7 Relationship to visa-author Run this skill after each table is drafted. The 19 rules partition naturally by the table they primarily concern, so a partial check after, say, T4 can already exercise r2, r3, r11–r13. Iterate until the summary reads 19/19 PASS. D.3 VISA Code-Generation Skill Purpose. Convert a complete, rule-passing set of eight VISA tables (Markdown, as produced by visa-author) into a runnable agent-based simulation in Python or Java. This skill closes the loop from specification to executable implementation. D.3.1 When to invoke Invoke when a reproducer has the eight VISA tables (md) and wants to generate / scaffold / implement the simulation code. Best run after visa-check reports 19/19 PASS; on partial specs it emits explicit TODO stubs for the gaps. D.3.2 Inputs • The eight VISA tables in Markdown (T1–T8). • Target language: Python (default) or Java. • Optional framework: Python → plain or Mesa; Java → plain or Repast Simphony. • Optional random seed. D.3.3 Companion skills This is the third VISA skill, complementing visa-author (build tables) and visa-check (verify rules). Together: author → check → code. D.3.4 Output: project layout project/ |-- README.md # how to run + VISA->code map |-- config.* # T6a parameters (+ Derivation metadata) |-- data/ # T5 datasets (or download stubs) | ‘-- loaders.* # one loader per T5 record |-- agents/ # T1 + T2 + T4 | |-- environment.* | |-- space.* | |-- vendor.* | ‘-- ... |-- sensing.* # T3 access-control layer |-- model.* # T7 schedule + T7b termination |-- collectors.* # T6b outputs (Frequency-aware) |-- validation.* # T8 post-run analyses ‘-- main.* # entry point D.3.5 Architecture mapping VISA element Code construct T1 Category Environment/Space → infrastructure base; Decision-maker → active base with step; Passive → data-only class (no behavior) T1 Quantity N / n fixed list vs. dynamic collection supporting add/remove T2 variable instance attribute / field T2 Data Type language type (see table below) T2 exogenous constructor parameter (value supplied from T6a) T2 endogenous computed attribute, written by the owning T4 function T3 sensing getter methods + an access-control layer enforcing the matrix T4 function (f-ID) one method on the owning agent class T4 Decision Basis the variables the method reads (self attributes + sensed) T4 Self-state Update self.x = … writes inside the method T4 External Effect calls to other agents’ setters T4 Method / Ref the algorithm body; cite Ref in a comment T5 data record a loader (CSV/JSON) T6a input config / params object T6b output collector, sampled at the recorded Frequency T7a schedule Model.step(): ordered function calls per step T7a Exec.mode see patterns below T7b termination while-loop condition re-checked each step T8 validation post-run analysis script Data Type → language type VISA Data Type Python Java Float float double Boolean bool boolean List[Integer] list[int] ArrayList<Integer> Matrix[Integer] numpy.ndarray (2-D, int) int[][] List[Float] list[float] ArrayList<Double> (extend analogously) … … D.3.6 Exec.mode implementation patterns (critical for reproducibility) The execution mode is the single biggest source of irreproducibility. Generate the pattern exactly as T7a records it. • Synchronous — snapshot then swap. Each instance reads all Decision-Basis variables into locals, computes its update, and only after all instances have computed do they write back simultaneously. • Sequential (order…) — process instances one at a time in the stated fixed order (e.g., by ID; by wiw_i descending); each write is immediately visible to later instances. • Random-order — as Sequential, but shuffle the instance list with the seeded RNG at the start of every step. • Asynchronous (dist…) — event-driven: each instance draws a next-activation time (e.g., Poisson(λ)); a priority queue fires activations; the global step is bookkeeping. Rule r4 (same Step ⇒ same Exec.mode) means a whole Step uses one pattern — generate one block per Step. Illustrative skeleton (Python, one Step) # Exec.mode = Synchronous -> snapshot-then-swap olds = [v.read_basis() for v in vendors] # snapshot news = [update_from(o) for o in olds] # compute, no writes yet for v, n in zip(vendors, news): # swap simultaneously v.commit(n) # Exec.mode = Random-order -> shuffle, then in place rng.shuffle(vendors) for v in vendors: v.update_in_place() # writes visible to later vendors D.3.7 Generation pipeline (ordered) 1. Parse the eight md tables into a structured representation (agent types, variables, functions, schedule, …). 2. Config — emit config from T6a: every exogenous parameter, its value/distribution, Derivation, and the loader it needs. 3. Data loaders — for each T5 record, emit a loader honoring Availability: Open → direct path/URL; Restricted/Private → stub that raises a clear “data unavailable” error (see Section 4.3, data bottleneck). 4. Agent classes — for each T1 type: attributes from T2 (typed per the table above), a constructor taking the exogenous parameters, and one method per owned T4 function. Translate each function’s Method: • mechanical (Mean, Arithmetic, Append, Comparison, Transfer, Conditional, Optimization) → direct implementation; • literature-grounded (Multinomial logit, Preferential attachment, newsvendor fractile, …) → translate the paper’s equation, cite the Ref in a comment; • under-specified → emit a clearly marked TODO(ref=…) so the reproducer confirms the exact form. 5. Sensing layer — emit getters; add an access-control wrapper enforcing T3 (default: open getters with a comment documenting where T3 restricts access, plus an optional strict mode). 6. Model — emit agent collections, a step() executing T7a Steps in order (with the Exec.mode pattern per Step), and the termination loop from T7b. 7. Collectors — for each T6b output, emit a recorder honoring Frequency (k≥1k≥ 1 every k steps; −1-1 terminal only). 8. Validation — for each T8 row, emit the post-run computation + statistical test (K-S, Moran’s I, regression, …) + passing-condition check against the benchmark. 9. Main + README — wire everything; the README documents how to run, the RNG seed, and a table mapping every generated file back to its VISA source. D.3.8 Reproducibility safeguards (emit by default) • A single seeded RNG threaded through every stochastic draw (T6a distributions, Random-order shuffles, Asynchronous activation, stochastic methods). • Every T4 method body cites its Ref in a comment. • A --seed CLI flag and a recorded seed in the run log. • The T3 sensing matrix reproduced as a docstring/comment on the sensing layer, so a reproducer can audit information flow. D.3.9 Common pitfalls 1. Wrong Exec.mode — silently changes results; verify each Step against T7a. 2. Implicit synchronous assumption — if T7a says Synchronous but the code updates in place, results differ; always snapshot-then-swap for Synchronous. 3. Unseeded randomness — without a threaded seed, re-runs diverge. 4. Open access vs. T3 — generating public getters for everything violates the model’s rationality bounds; at minimum document the T3 restrictions. 5. Restricted/Private data (T5) — the loader cannot fetch these; emit a clear stub so the reproducer knows reproduction is blocked at data acquisition. 6. Passive agents with methods — r6 forbids this; if it appears, the spec failed visa-check and should be corrected before code generation.