Procela: Epistemic Governance in Mechanistic Simulations Under Structural Uncertainty

Procela is a novel Python framework that enables mechanistic simulations to dynamically restructure their own architecture at runtime through structural mutation, allowing them to add entirely new mechanisms, remove failing ones, alter resolution policies, and modify the causal graph itself with automatic reversion on failure, thereby achieving significant improvements in accuracy and decision-making in complex scenarios like antimicrobial resistance spread.

The Gist

Imagine you are trying to navigate a ship through a stormy ocean, but you have a problem: you don't know which map is correct.

Sometimes the storm is caused by a hidden reef (Contact), sometimes by a sudden shift in the wind (Environment), and sometimes by a malfunctioning engine (Selection). In the past, scientists would pick one map, stick with it, and hope for the best. If the map was wrong, the ship would crash, and the scientists would only realize it after the damage was done.

Procela is a new kind of navigation system that changes the rules. Instead of picking one map and sticking with it, Procela keeps all three maps on the table at the same time. But more importantly, it gives the ship a self-correcting brain that constantly asks: "Is our current map working? If not, let's try a different one."

Here is how it works, broken down into simple concepts:

1. The "Talking" Variables (The Epistemic Authorities)

In a normal computer simulation, a variable (like "Number of Sick Patients") is just a number. It holds a value and waits for the next step.

In Procela, variables are like wise judges. They don't just hold a number; they hold a memory of every guess ever made about that number.

• Mechanism A (The Contact Map) says: "I think there will be 50 sick people."
• Mechanism B (The Environment Map) says: "I think there will be 80."
• Mechanism C (The Selection Map) says: "I think there will be 30."

The "Judge" (the variable) remembers all three guesses, who made them, and how confident they were. It then uses a rule (like a vote or picking the most confident guess) to decide the final number. Crucially, it never deletes the old guesses. This means you can always look back and see why the system made a decision.

2. The "Scientist" Mechanisms

The different maps are called Mechanisms. Think of them as different scientific theories arguing with each other.

• The Contact Team believes the sickness spreads by people shaking hands.
• The Environmental Team believes it spreads through dirty water.
• The Selection Team believes it spreads because of too many antibiotics.

In a normal simulation, you have to pick one team to be the boss. In Procela, all three teams are working at once, shouting their predictions. The system listens to all of them.

3. The "Governor" (The Self-Correcting Brain)

This is the magic part. Procela has a Governor that watches the judges and the teams. It doesn't just watch the numbers; it watches the confidence of the teams and the health of the system.

The Governor is domain-agnostic, meaning it doesn't know what "disease" or "climate" means—it only knows how to manage the simulation. It operates through four general capabilities:

• Observe: It monitors specific signals that the user defines for their specific domain.
• Decide: It triggers actions when those signals cross certain thresholds (e.g., if a signal gets too high or too low).
• Act: This is where the real power lies. The Governor can:
  • Add new mechanisms that didn't exist when the simulation started.
  • Remove failing mechanisms entirely.
  • Change resolution rules (e.g., switching from a weighted vote to picking the single highest-confidence guess).
  • Run experiments that alter the causal graph of the simulation itself.
• Learn: It keeps successful configurations and automatically reverts failed ones. If a new rule makes things worse, the ship immediately goes back to the previous safe configuration.

To put this in terms of the ship analogy: a traditional ensemble method is like having three fixed maps and switching between them. Procela goes further — it can draw a brand-new map mid-voyage, add a new instrument that wasn't there before, or change how the captain interprets the compass. If the new map or instrument makes navigation worse, the ship automatically reverts to the previous configuration. The ship doesn't just choose among fixed maps — it redesigns its own navigation system while sailing.

4. The Real-World Test: The Hospital (AMR Case Study)

The authors tested this on a hospital simulation dealing with Antimicrobial Resistance (AMR) (superbugs).

• The Problem: Superbugs spread in hospitals, but nobody knows exactly how (is it the nurses? the air? the drugs?).
• The Old Way: Pick one theory, simulate, and hope.
• The Procela Way: Let all theories compete. The Governor uses domain-specific signals to manage the simulation. In this specific hospital test, the signals were:
  • Coverage: Measuring prediction accuracy for each mechanism family. If the "Contact" family kept making bad predictions, the Governor noticed the low accuracy score.
  • Fragility: Measuring disagreement on which intervention to apply. If the Contact team said "Isolate patients" and the Environmental team said "Clean the floors," the Governor saw high disagreement and knew the system was confused.
  • Probe: Temporarily isolating a mechanism family to measure its standalone performance. The Governor might say, "Let's turn off everyone except the Environmental team for a moment to see if they perform better alone."

When the "Contact" theory failed (because the real problem was actually "dirty water"), the Governor noticed the Coverage signal dropped and the Fragility signal spiked. It then Acted by removing the Contact theory from the simulation entirely, allowing the Environmental theory to take over.

The Result?

• Procela reduced prediction errors by 20%.
• It made better decisions about which medicine to use or which rooms to clean.
• Most importantly, it didn't crash. When it tried a new rule and it failed, it immediately went back to the safe rule.

Why This Matters

Imagine a self-driving car that doesn't just follow a map, but learns that the map is wrong when it hits a pothole, and instantly switches to a different map that accounts for potholes.

Procela turns computer simulations from static statues (fixed models that can't change) into living scientists (models that question themselves, run experiments, and adapt).

In short:

• Old Simulations: "I believe this is true. I will ignore everything else."
• Procela: "I have three theories. I will test them all, fire the ones that fail, and promote the ones that work. I am learning as I go."

This is a huge step forward for fields like climate change, economics, and medicine, where the "rules of the game" change constantly, and we need models smart enough to realize when they are wrong.

Technical Summary

1. Problem Statement

Mechanistic simulations traditionally rely on fixed ontologies, where variables, causal relationships, and resolution mechanisms are defined statically before execution. This paradigm fails when the true causal structure of a system is contested, unidentifiable, or dynamic.

• The Core Issue: In complex domains like Antimicrobial Resistance (AMR) spread, multiple competing causal explanations (e.g., contact transmission vs. environmental reservoirs vs. antibiotic selection pressure) may exist simultaneously. Observational data often cannot distinguish between them.
• The Limitation: Forcing a single ontology at the start discards epistemic uncertainty. Existing methods (model averaging, robust control, adaptive management) operate within fixed structures and cannot dynamically question or mutate the model's fundamental assumptions based on runtime evidence.

2. Methodology: The Procela Framework

The authors introduce Procela, a Python 3.10+ framework that elevates epistemic uncertainty from a pre-simulation concern to a runtime governance process. The framework treats the simulation not as a static artifact but as an evolving hypothesis capable of self-correction through structural mutation.

Core Abstractions

Procela is built on four fundamental components:

1. Variables as Memory-Bearing Epistemic Authorities:
   • Unlike traditional variables that hold a single value, Procela variables maintain a complete, append-only history of competing hypotheses.
   • Each hypothesis includes a proposed value, confidence score, source (mechanism ID), and timestamp.
   • Variables resolve conflicts using Resolution Policies (e.g., weighted voting, highest confidence, median), which can be changed dynamically during execution.
2. Mechanisms as Causal Units:
   • Mechanisms encode specific scientific theories (causal hypotheses). They read variables, apply transformations, and write new hypotheses to variables.
   • Multiple mechanisms can compete to explain the same phenomenon, representing different scientific perspectives.
3. Governance as a First-Class Citizen:
   • Governance is the ability to mutate the system's structure (topology) during execution based on epistemic signals.
   • Invariants: Second-class objects that observe state and trigger actions (e.g., detecting coverage decay).
   • Hooks: First-class objects that can trigger structural changes before or after simulation steps.
   • Mutation Operations: Governance can add new mechanisms that did not exist at initialization, remove failing mechanisms entirely, alter variable domains, or change resolution policies. This distinguishes Procela from ensemble methods that merely re-weight existing components.
4. Executive:
   • Orchestrates the simulation loop, managing the random number generator, step counter, and logging. It executes mechanisms, resolves variables, and evaluates invariants in three phases: PRE (pre-execution), RUNTIME (post-hypothesis generation), and POST (post-resolution).

The Governance Lifecycle

Procela implements a scientific method loop at runtime:

1. Observation: The Governor observes domain-defined signals (e.g., prediction error, policy disagreement) against user-defined thresholds.
2. Hypothesis: Based on these signals, the Governor formulates a structural change (e.g., "Add a new mechanism," "Remove a failing family," "Alter the causal graph").
3. Experiment: The change is applied for a fixed duration to test its efficacy.
4. Evaluation: The system compares performance metrics before and after the experiment.
5. Conclusion: If the experiment improves outcomes, the structural change is retained; otherwise, it is automatically reverted, ensuring the system does not degrade due to failed experiments.

3. Case Study: AMR in Hospital Networks

The framework was instantiated to simulate the spread of antimicrobial-resistant organisms in a hospital network with three interconnected units. This section demonstrates how the generic Procela capabilities are applied to a specific domain.

• Competing Ontologies: Three mechanism families were defined to represent distinct causal theories:
  1. Contact: Transmission via patient contact.
  2. Environmental: Transmission via contaminated surfaces/air.
  3. Selection: Spread driven by antibiotic usage pressure.
• Ground Truth: The simulation environment underwent three distinct regime shifts (Selection $\to$ Environmental $\to$ Contact), which the mechanisms had to infer from data without direct access to the underlying parameters.
• Domain-Specific Signals: In this specific instantiation, the Governor monitored three custom signals to trigger governance actions:
  • Coverage: Measures prediction accuracy per mechanism family.
  • Policy Fragility: Measures disagreement among mechanisms regarding the optimal intervention.
  • Recent Error: Rolling average of prediction error.
  • Note: These signals are domain-specific instantiations. The Procela framework itself does not hard-code these metrics but allows users to define any signal to drive structural mutations.

4. Key Contributions

1. Conceptual Architecture: Formalizes "epistemic governance," defining variables as memory-bearing authorities and governance as runtime structural mutation (adding/removing mechanisms, altering causal graphs) based on epistemic signals.
2. Open-Source Implementation: A fully reproducible Python framework with full auditability (cryptographic source tracking for every hypothesis and structural change).
3. Empirical Demonstration: A rigorous case study showing how governance adapts to regime shifts by dynamically altering the simulation architecture.
4. New Paradigm: Establishes simulations that model their own modeling process, enabling adaptation under structural uncertainty, distinct from static model averaging.

5. Results

Experiments were run over 160 steps with 50 independent trials. The results compared a Baseline (static model, no governance) against three governance strategies utilizing the AMR-specific signals described above:

Strategy	Mean Absolute Error (MAE)	Improvement vs. Baseline	Cumulative Decision Regret
Baseline	0.535	-	-
Policy Fragility	0.544	-1.6% (Worse)	-9.8%
Coverage Decay	0.426	+20.4%	+35.5%
Structural Probe	0.485	+9.3%	+69.0%
Combined	0.491	+8.2%	+61.6%

Key Findings:

• Coverage Decay Governance: Achieved the largest reduction in prediction error (20.4%). It successfully detected when a mechanism family (e.g., Contact) was failing in a new regime and removed it from the active set, preventing the "bad" model from dragging down the ensemble.
• Structural Probe Governance: Achieved the highest improvement in decision-making (69% reduction in regret). By periodically isolating families to test their standalone performance (a structural experiment), it identified the correct intervention strategy faster, even if its raw prediction error improvement was modest.
• Policy Fragility: Failed to improve predictions because switching from weighted voting to "highest confidence" was suboptimal under the specific noise conditions, though it provided valuable diagnostic data.
• Regime Detection: Governance successfully identified regime shifts. Experiments triggered during high-error periods had a 71% success rate, while those triggered during stable periods failed, proving the system targets crises effectively.
• Trade-offs: There is a fundamental trade-off between prediction optimization (Coverage Decay) and decision optimization (Structural Probe).

6. Significance and Implications

• Simulations as Scientists: Procela internalizes the scientific method. The simulation autonomously detects anomalies, formulates hypotheses about model adequacy, runs structural experiments, and updates its beliefs without human intervention.
• Beyond Model Averaging: Unlike Bayesian model averaging (which combines fixed models), Procela allows the set of models itself to change. It performs structural learning at runtime by adding, removing, or altering mechanisms, rather than just re-weighting existing ones.
• Auditability: Every governance action, hypothesis, and mutation is cryptographically tracked, creating a complete, transparent history of the model's evolution. This is crucial for high-stakes domains like healthcare or climate policy.
• Domain Agnosticism: While tested on AMR, the framework is designed for any domain with competing causal theories (e.g., climate modeling, economics, robotics). The specific signals used in the case study are user-defined, not intrinsic to the framework.
• Future Directions: The paper suggests future work in meta-governance (tuning thresholds automatically), multi-objective optimization, and real-world deployment in operational settings.

In conclusion, Procela demonstrates that treating simulations as adaptive, self-questioning systems capable of runtime structural mutation can significantly reduce error and improve decision-making in environments where the underlying causal structure is uncertain and dynamic.