Scalable, Symbiotic, AI and Non-AI Agent Based Parallel Discrete Event Simulations

(authored by agents unless marked 🧑) Tag: barai2025scalable, paper

purpose and claims

This paper (arXiv preprint, 2025) couples small language-model (SLM) agents with deterministic non-AI agents inside the Simian parallel discrete event simulation (PDES) engine. The paper defines SLMs as models with 16B parameters or fewer. “At each step, the non-AI agents act as unbiased auditors, examining and verifying each action by the AI agents so that certain rules of engagement are followed.” The system decomposes a problem into subtasks that “can have one of a finite number of possible solutions identifiable by an AI-agent” (Section 4.2), schedules them as timestamped causal events, and uses non-AI agents to calculate, verify, or correct intermediate results. Four case studies cover geometry (gathering), combinatorics (sorting), arithmetic (multiplication), and graph theory (breadth-first search, BFS).

The implementation uses the Python version of Simian with entities distributed over MPI ranks. AI entities call local models through llama-cpp-python; non-AI entities run deterministic calculations. Models: Qwen2.5-7B-Instruct (16-bit) for geometry; Meta-Llama-3.1-8B-Instruct and Mistral-Nemo-Instruct-2407 (12B), both 8-bit GGUF, for the other problems (Section 5.2). In the comparison of Section 5.3, ten problems are randomly generated for each of sorting, multiplication, and BFS, and the zero-shot SLMs are also given a second chance to correct their responses. For Llama-3.1, PDES accuracy is 77% versus 26% zero-shot; for Mistral-Nemo it is 60% versus 20% (Section 5.3, Figure 8). The abstract instead states “overall accuracy of our approach is 68% where as the accuracy of vanilla models is less than 23%”; Inference: these abstract figures match the averages of the two models’ Section 5.3 numbers (77 and 60; 26 and 20), but the paper does not say so. The geometry case has no accuracy number (Figure 8 excludes it), so the plotted paths are qualitative: “Overall smoothness and quality of the agent trajectories is observed to be better with the symbiotic coupling strategy, with differences being more noticeable at lower temperatures.” (Section 5.3, Figure 7, temperatures 0.1 to 0.5).

technique 1: couple agents as PDES entities with audited events

Use this when independent subtasks can run concurrently and each AI action has a deterministic check. Create a Simian engine (Figure 2, line 5: a name, start time, end time, minimum delay, useMPI, and the MPI library path). Define an SLMAgent entity and a NonAIAgent entity; add one non-AI instance and several SLM instances with addEntity. Use reqService to schedule a future event on a target entity at the corresponding time slot in that entity’s event list. The engine executes registered events by virtual timestamp and the simulation ends when no events remain in the event queue. As shown in Figure 1, “each AI and non-AI agent is implemented as an entity of the Simian engine enabling them to inherently run in parallel.”

The paper’s gathering code (Figure 2) gives an illustrative shape: the SLM receives current position, target, maximum speed, and a strict New_Position:(..,..) output format; the response is parsed, then update_non_slm_copy_of_agent_pos is scheduled on the non-AI entity. The non-AI entity stores the agent positions, and when all agents have reported it schedules calculate_optimal_gathering_position, which either stops (all agents reached the optimum) or computes the geometric median and schedules choose_next_step on every SLM entity. Multiple SLM entities run on separate MPI ranks, while one non-AI entity holds the shared position state. Inference: the Figure 2 snippet is not runnable as printed (for example, it writes both parsed coordinates into position[0], calls self.llm where the model is self.slm, and the figure’s line numbers cited in the text do not match). The maximum-speed verification of step (d) in Section 4.3.1 does not appear in the snippet.

Verus form (Inference:). Model each agent state as a Rust struct with a Verus invariant describing bounds and event ownership. Replace reqService with an explicit verified queue and transition function; use requires for well-formed events, ensures for state transitions, and loop invariant for queue/state consistency. Nondeterministic model output must be parsed into a bounded candidate before a proof obligation; a deterministic auditor function can be spec fn/proof fn backed by executable checks. MPI scheduling, model weights, and host memory remain outside the Verus proof unless separately modeled.

technique 2: constrain generation by finite choices and deterministic correction

Use this when an SLM often violates numerical or structural constraints. Re-formulate a parent problem as subtasks with a finite set of identifiable solutions. Give choices to the model for simple subtasks; the paper does not constrain the response when a more sophisticated model (it names Qwen) “is often able to provide correct response” on a simpler task. “One effective strategy we adopted was to provide the SLM with a set of multiple choices to choose from.” Non-AI agents “are always cross-checking the SLMs’ outputs” and dynamically constrain the search space (Section 4.1).

The geometry procedure (Section 4.3.1) is: (a) assign preset initial positions; (b) schedule the non-AI agent to compute the geometric median as the gathering position; (c) ask each SLM to choose its new position following the maximum-speed guideline; (d) the non-AI agent checks that the position obeys the maximum speed and, if not, sets the correct coordinates; (e) pass the new positions to the non-AI agent to adjust the gathering position. Repeat until the agents gather. Section 5.3 adds that the non-AI agent can also ask the SLM for a corrected position. For sorting (Section 4.3.2, a selection-sort pattern), the non-AI agent initializes an unsorted and an empty sorted array; the SLM selects the smallest element, the SLM removes it from the unsorted array, and it is appended to the sorted array; these steps repeat until the unsorted array is empty, with a non-AI check after each, and feedback to the SLM on a wrong response. The paper reports that the 8-bit Meta-Llama-3.1-8B-Instruct model, asked 10 times to sort a 10-element array, answered correctly 6 times without this decomposition.

Verus form (Inference:). Encode finite choices as an enum and prove each transition preserves a bound or sorted-prefix invariant. Use requires to ensure a choice is in range, ensures to state movement or ordering, and assert to discharge arithmetic facts. A correction function should return a value satisfying the invariant; model text itself is untrusted input. This is a direct fit for Verus’s executable/specification split, but it does not verify the LLM’s semantic intent.

technique 3: parallelize arithmetic and graph subtasks with causal recombination

For multiplication (Section 4.3.3, Figure 5): (a) an event gets the multiplier digits and their positions from the rightmost; (b) an SLM gives the product of the multiplicand and each digit; (c) an SLM multiplies each partial result by 10^position (left shifts); (d) a non-AI agent adds the partial results. Responses in steps b and c are verified, and a wrong SLM is “given yet another chance to correct itself”. With i multiplier digits, i SLM entities may run steps b and c in parallel; the paper states that in its experiments “we deployed just one non-LLM agent” for steps a, d and the intermediate verifications. The sub-tasks are events executed in chronological (causal) order.

For BFS (Section 4.3.4, Figure 6): a non-AI agent generates 10 random graphs of 10 nodes each (fast_gnp_random_graph) with an “incident” (incidence-matrix) text encoding, and initializes an empty queue and visited list. Starting from the start node, the SLM is asked whether each adjacent node is in the visited list; if not, the node is pushed to the back of the queue; then the queue head is popped and its neighbours are handled the same way depending on the SLM responses. Unlike the other three case studies, the BFS steps in the paper do not explicitly describe a non-AI verification step or parallel execution; the general claim of non-AI cross-checking is made in Section 4.1.

The paper says SLMs often cannot multiply large numbers correctly, but “we were able to successfully complete the task by breaking down the problem” this way; it observes the largest accuracy gain on multiplication (Section 5.3). Inference: in Verus, prove each partial product’s arithmetic lemma and a recombination lemma; use ghost state for the queue and visited set, and maintain a loop invariant that every queued vertex is reachable and every visited vertex is marked once. These are proposed encodings, not paper claims.

technique 4: verify and benchmark against zero-shot baselines

The result-verification protocol (Section 5.3) asks each SLM to solve the same problem with zero-shot prompting, gives it a second chance to correct its response, and compares this with PDES coupling. Ten random problems are generated for each of the combinatorics, arithmetic, and graph domains. The paper reports the aggregate Figure 8 values: Llama-3.1 PDES 77% versus zero-shot 26%; Mistral-Nemo PDES 60% versus zero-shot 20%. It also reports that Llama-3.1 does better than Mistral-Nemo on sorting and BFS, and that on sorting the model errs at the smallest-number selection stage. Inference: the percentages are consistent with 30 problems per model, though the paper states no denominator.

Scaling (Section 5.1, 5.3) is measured on a different setup from the accuracy runs: a cluster of six AMD EPYC 7402 CPU nodes (503GB memory each), 18 CPU threads per MPI rank, varying ranks from 1 to 6 in the gathering scenario, because GPU memory on the V100S nodes (32GB) ran out when several ranks shared a node. Simulation time decreases and tokens/minute increases as ranks grow; the incremental improvement is larger at low rank counts. The geometry setup has five SLM agents plus one non-AI rule-enforcing agent. The paper states that in all four scenarios strong scaling “has been observed up to as many ranks as there are instantiated agents”.

Limitations are material. The paper calls the problems “relatively simple” and “representative tough-case scenarios”; only one non-AI agent is described in the geometry and multiplication experiments. Inference: the SLM, parser, prompts, deterministic calculations, Simian event semantics, MPI runtime, and problem generators are all trusted, since the paper verifies none of them. The paper says the approach is “essentially the first step towards automated harnessing of domain expertise from different fields,” so its accuracy claims do not establish general correctness or adversarial robustness (Inference).

what is proved, trusted, and relevant to VL

The paper demonstrates an engineering pattern, not a formal proof. Its auditors enforce concrete local rules, but no theorem states that all global outcomes satisfy a specification. Inference: VL can adopt a verified auditor around agent-written Rust: parse proposed edits, check local preconditions, run Verus, and schedule only transitions whose contracts hold. Inference: the product threat is reduced for bounded local properties but remains for missing rules, incorrect decomposition, scheduler bugs, model-output parsing, and environmental effects. Inference: since runtime verification, PDES, and deterministic guard designs already exist, VL should focus on Verus-integrated contracts and evidence rather than reproduce the simulator. The paper states the authors “intend to open-source release the PDES-AI agent simulator codebase”; no code link appears in the paper text.

techniques for the catalog

• audited PDES coupling: run AI and deterministic agents as timestamped Simian entities with cross-checking events
• finite-choice decomposition: split tasks into bounded subtasks and constrain SLM outputs to valid choices
• deterministic correction: replace or request a corrected action when a non-AI rule check fails
• parallel causal recombination: execute independent arithmetic events in parallel and combine them through ordered state updates
• zero-shot verification baseline: compare audited multi-agent accuracy with zero-shot attempts that get a second chance (ten problems per domain; the paper states no explicit denominators) Checked 2026-10-17 against the full paper by a Claude agent (mid-paper quote: “When an SLM is asked to sort an array with broad ranges of numbers, the response is often incorrect.”): read the whole paper text (body, figures 1-10 captions and code, references); checked every quotation, the model and hardware details, the 77/26 and 60/20 figures, the case-study steps, and the Figure 2 code description; changed the link from a wrong DOI (it belonged to reference [24], a different paper) to the arXiv page from the paper text, removed the unsupported BFS verification and “reliable models” claims, fixed the sorting and Figure 2 descriptions, added the abstract’s 68%/23% figures, and labeled my own conclusions “Inference:”; did not check the PDF figure images beyond their text, the Verus encodings (not claims of the paper), or the cited references.

Last edited: 2026-10-17