1. From Concept to First Prototype
2. Towards the Perfect Prompt
3. Stress Testing the System

FOR EACH simulation day:
    // Step 1: Filter only susceptible agents
    susceptible_agents = agents WHERE state == 'S'
    FOR EACH agent IN susceptible_agents:
        // Step 2: Gather context about agent's neighbourhood
        nearby_agents = find_agents_within(observation_radius)
        stats = {
            total: count(nearby_agents),
            infected: count(nearby_agents WHERE state == 'I'),
            susceptible: count(nearby_agents WHERE state == 'S'),
            recovered: count(nearby_agents WHERE state == 'R')
        }
        // Step 3: Create personalised prompt
        prompt = """
            {agent.persona}
            
            Nearby: {stats.total} people, {stats.infected} infected.
            Should you isolate? Reply: YES/NO then reason briefly.
            Answer:
        """
        // Step 4: Send prompt to LLM (via KoboldCPP API)
        response = await query_llm(prompt)
        // Step 5: Parse LLM response
        IF response contains "YES" in first 50 characters:
            agent.will_isolate = True
        ELSE IF response contains "NO" in first 50 characters:
            agent.will_isolate = False
        ELSE IF response is error OR unclear:
            // Fallback rule: isolate if many infected nearby
            agent.will_isolate = (stats.infected > 2)
        // Step 6: Log decision for analysis
        log(day, agent, stats, decision, reasoning)
    // Step 7: Apply isolation behaviour
    FOR EACH agent:
        IF agent.will_isolate:
            // Isolated agents move slower
            agent.move(isolated_speed)  // 20% of normal speed
        ELSE:
            agent.move(normal_speed)
    // Step 8: Disease spread (respects isolation decisions)
    FOR EACH infected_agent WHERE state == 'I' AND NOT will_isolate:
        nearby = find_agents_within(infection_radius, infected_agent)
        FOR EACH other IN nearby:
            IF other.state == 'S' AND NOT other.will_isolate:
                IF random() < infection_probability:
                    other.infect()  // Becomes infected

• Prompt sent to LLM: "Cautious healthcare worker, isolates early. Nearby: 7 people, 2 infected. Should you isolate? Reply: YES/NO then reason briefly."


• LLM responds: "YES. As a healthcare worker, I understand transmission risks. Two infections nearby is significant, and early isolation prevents spread."


• Result: Agent isolates and moves at isolated_speed (20% of normal speed). While isolated, they are skipped during disease spread calculations, so they cannot catch the disease in that particular step.


• Each day, susceptible agents re-evaluate their decision by querying the LLM again with updated neighbourhood statistics.

• Details submitted: Social person, finds isolation difficult. Nearby: 4 people, 0 infected.
• Response: Isolation: NO. Reasoning: The individual is a nearsighted person who struggles with social interactions. Given the low infection rate of 0%, it's unlikely that they would be exposed to an infectious person nearby. Therefore, isolating them could potentially harm their mental health and social connections.

• Agents have no memory: They do not learn from past decisions or infection trends
• Prompts are too generic: They lack simulation context and temporal awareness
• Decision parsing is weak: Simple keyword matching overrides persona logic
• No decision validation: Persona-inconsistent decisions are not corrected

• Context-rich prompts: Include trends, history, and simulation state
• Persona validation Enforce persona-consistent behaviour
• Memory system: Learn from past outcomes and patterns
• Reasoning quality scoring: Measure and improve decision quality
• Feedback loops: Use outcomes to refine future prompts

def simulate_day_synchronous(self):
    # Phase 1: All agents decide based on the same world state
    decisions = [agent.make_decision(self.world_state) for agent in self.agents]

    # Phase 2: Apply all decisions simultaneously
    for agent, decision in zip(self.agents, decisions):
        agent.apply_decision(decision)

async def simulate_day_concurrent(self):
    # Phase 1: All agents make decisions concurrently
    decision_tasks = [agent.make_decision() for agent in self.agents]
    decisions = await asyncio.gather(*decision_tasks)

    # Phase 2: Apply all decisions after reasoning completes
    for agent, decision in zip(self.agents, decisions):
        agent.apply_decision(decision)

class Simulation:
    def __init__(self, max_concurrent_requests=50):
        self.semaphore = asyncio.Semaphore(max_concurrent_requests)
    
    async def make_decision_with_limit(self, agent):
        async with self.semaphore:
            return await agent.make_decision()
    
    async def simulate_day(self):
        tasks = [self.make_decision_with_limit(agent) 
                 for agent in self.agents]
        decisions = await asyncio.gather(*tasks)

async def make_decision_with_retry(self, agent, max_retries=3):
    """Make a decision with exponential backoff retry logic."""
    for attempt in range(max_retries):
        try:
            async with self.semaphore:
                response = await agent.make_decision()
                # Validate response format
                if not self.is_valid_decision(response):
                    raise ValueError(f"Invalid decision format: {response}")
                return response
                
        except (asyncio.TimeoutError, aiohttp.ClientError) as e:
            if attempt == max_retries - 1:
                # Final attempt failed - use fallback
                self.log_error(f"Agent {agent.id} defaulting after {max_retries} attempts")
                return agent.get_default_decision()
            
            # Exponential backoff: wait 1s, 2s, 4s...
            wait_time = 2 ** attempt
            await asyncio.sleep(wait_time)
            
        except Exception as e:
            self.log_error(f"Unexpected error for agent {agent.id}: {e}")
            return agent.get_default_decision()

def build_agent_prompt(self, agent):
    return f"""You are {agent.name}, age {agent.age}.
    
Current Health Status: {agent.health_status} ({agent.sir_status})
Local Infection Rate: {self.get_local_infection_rate(agent.location)}%
Nearby Hospital Capacity: {self.get_hospital_capacity(agent.location)}
Your Symptom Severity: {agent.symptom_severity}/10
Available Actions: stay_home, go_to_work, seek_medical_care, visit_shop
Current Date: Day {self.current_day} of epidemic

Based on this information, what will you do today?
Respond with a single action and brief reasoning.
Format: ACTION:  | REASONING: """

def compress_agent_memory(self, agent):
    """Compress old memories when approaching context limits."""
    if len(agent.history) > 10:
        # Keep recent interactions, summarise older ones
        recent_events = agent.history[-5:]
        old_events = agent.history[:-5]
        
        summary_prompt = f"""Summarise these past events in 2-3 sentences:
        {old_events}"""
        
        summary = await self.llm_client.generate(summary_prompt)
        agent.history = [f"[SUMMARY] {summary}"] + recent_events

async def make_deterministic_decision(self, agent):
    """Generate deterministic decisions for reproducible simulations."""
    response = await self.llm_client.generate(
        prompt=self.build_agent_prompt(agent),
        temperature=0.0,  # Deterministic mode
        seed=42  # Some APIs support explicit seeding
    )
    return response

1. Baseline Comparison: Compare LLM agent behaviour against rule-based equivalents

def validate_against_baseline(self):
    """Compare LLM agents to rule-based agents on known scenarios."""
    scenarios = self.generate_test_scenarios()
    
    for scenario in scenarios:
        llm_decisions = self.run_llm_agents(scenario)
        rule_decisions = self.run_rule_agents(scenario)
        
        agreement_rate = self.calculate_agreement(llm_decisions, rule_decisions)
        
        if agreement_rate < 0.7:
            self.log_warning(f"Low agreement on scenario: {scenario}")

2. Expert Review: Log agent reasoning and have domain experts review samples

def log_decision_with_reasoning(self, agent, decision, reasoning):
    """Log decisions for qualitative review."""
    self.decision_log.append({
        'timestamp': self.current_day,
        'agent_id': agent.id,
        'agent_state': agent.get_state_dict(),
        'decision': decision,
        'reasoning': reasoning,
        'world_state': self.world_state.copy()
    })

3. Sensitivity Analysis: Test how prompt variations affect aggregate outcomes

async def sensitivity_analysis(self):
    """Test robustness to prompt formulation."""
    prompt_variants = [
        self.build_prompt_conservative(),
        self.build_prompt_neutral(),
        self.build_prompt_detailed()
    ]
    
    results = {}
    for variant_name, prompt_builder in prompt_variants:
        self.set_prompt_builder(prompt_builder)
        outcome = await self.run_simulation()
        results[variant_name] = outcome
    
    self.analyse_variance(results)

1. Start with stateless agents: Only add memory if your research question requires it
2. Design self-contained prompts: Include all necessary context in each request with explicit format instructions
3. Use concurrent processing: Implement "asyncio.gather()" for realistic, unbiased decisions and dramatic performance gains
4. Limit concurrent requests: Use semaphores to prevent server overload and respect rate limits
5. Implement robust error handling: Use retry logic with exponential backoff and fallback decisions
6. Monitor token usage: Log prompt sizes to ensure you stay within limits
7. Control for non-determinism: Set temperature=0.0 for reproducible simulations
8. Validate systematically: Compare against baselines, conduct expert reviews, and perform sensitivity analyses
9. Test at scale gradually: Start with 10 agents, then 50, then 500—don't debug concurrency issues with thousands of agents

• Main Internship Report (09/2024): This report describes the following: Setting up an Ollama environment with a T4 GPU for LLM execution, implementing and testing GAML benchmark models (Game of Life, Predator-Prey, Schelling, Bass Diffusion, Adaptive Museum), and refining prompts for UML and GAML code generation. It automated EABSS workflows through Python scripting, tested multiple LLMs (Mistral, Llama 3.1, Gemma), and compared outputs. Additional work documented model setup, quantisation methods, syntax correction strategies, and improvements for multi-step model-to-code pipelines.


• Updates and Extensions 01 Report (12/2024): This report describes the following: Implementing GAML test models (Schelling, Bass diffusion, adaptive museum, Conway’s Life), developing a Python automation script for Ollama-based EABSS execution, and refining prompts for UML and GAML generation. It configured Mistral NeMo with optimised parameters and KV quantisation, iteratively improved multi-step GAML scaffolding, and benchmarked across scenarios. Additional work compared LLMs (NeMo, Llama3.1, Mistral-Small, StarCoder), analysed syntax errors, and explored fine-tuning requirements with detailed setup and configuration guides.


• Updates and Extension 02 Report (07/2025): This report describes the following: Refining Python automation scripts for EABSS with improved verbosity, context length handling, and API integration; creating new automation bots for OpenAI and Gemini models; enhancing test scenario prompts with consistent roles; restructuring EABSS scripts for small/medium versus advanced models; tuning Gemma 3 12B hyperparameters; systematically comparing Gemma 3 with Mistral NeMo; correcting and testing generated GAML scripts; and documenting fine-tuning protocols and Open WebUI usage.

• Problem Definition: This sets the entire research trajectory. Using LLMs here risks systematically ignoring marginalised voices who are underrepresented in training data, particularly problematic in participatory research where affected communities should drive question formulation.


• Conceptual Modelling: LLMs may obscure crucial assumptions and simplifications. While human modellers remain aware of what they are cutting away, LLMs present their outputs as complete without revealing eliminated alternatives, creating dangerous blind spots.


• Data Generation: Synthetic populations created by LLMs inherit unknown biases from base models. Recent research shows these biases transmit even through fine-tuning, with no reliable way to detect or eliminate them.

• Bias amplification: Are marginalised perspectives systematically excluded?
• Transparency loss: Can we trace and validate our modelling assumptions?
• Privacy violations: Does commercial LLM use expose participant data?
• False participation: Are we creating illusions of stakeholder engagement?
• Research integrity: How do we distinguish LLM-assisted from purely synthetic work?
• Accountability gaps: Who is responsible when LLM-generated models cause harm?

1. Epistemic Ethics concerns the pursuit of truth through transparent methodologies and the clear justification of knowledge claims.


2. Participatory Ethics focuses on ensuring genuine inclusion of all voices and actively mitigating inherent power asymmetries within the research process.


3. Research Ethics upholds standards of academic integrity, including the honest attribution of authorship and full disclosure of methods and influences.


4. Consequential Ethics evaluates the broader societal impact of research, aiming to prevent harm and mitigate the risks of long-term misuse.

• Clarity from the Start: The biggest new feature? A brand-new first step: Define Problem Statement. It might sound simple, but it's a game-changer. By starting with a clear articulation of what you're studying and why, you massively reduce confusion later down the line. No more vague goals or misaligned assumptions!
• Smarter Reuse, Less Rework: The second major upgrade is an instructional information reuse schema (we know, sounds fancy – but it's super helpful). This guides you to pull forward useful insights from earlier steps, so you're not constantly reinventing the wheel. Plus, it checks for any missing info in real time, like a helpful co-pilot reminding you to dot your i's and cross your t's.

• Poster 1: Everything you always wanted to know about Dr Siebers (academic details only :)
• Poster 2: Everything you always wanted to know about Dr Siebers (academic details only :) - 2e
• Poster 3: Exploring the Role of Generative AI in Advancing Agent-Based Model Design and Implementation