Why Causal DAGs Change Everything

Government & Policy

Multi-agent AI systems are increasingly used to analyze policy proposals: one agent gathers economic data, another models demographic impact, a third evaluates legal precedent, and a coordinator synthesizes their findings into a recommendation. The problem is that when a system recommends "Fund Program X," elected officials and the public have no way to understand why.

PyRapide changes this by building a causal DAG of the entire analysis process. Every data source consulted, every intermediate conclusion drawn by each agent, and every reasoning step that contributed to the final recommendation is captured as a causally linked event.

# Trace the full decision provenance of a policy recommendation
from pyrapide import queries

# Given the final recommendation event, trace backward
recommendation = poset.find_by_name("PolicyCoordinator.recommendation")[-1]
provenance = queries.backward_slice(poset, recommendation)

# provenance now contains every event that causally contributed
# to this recommendation: data fetches, agent analyses, intermediate
# conclusions, and the synthesis steps
for event in provenance:
    print(f"{event.name}: {event.payload}")

With queries.backward_slice(), an auditor can start from any recommendation and trace the complete decision provenance -- which datasets were consulted, which agent drew which conclusion, and how those conclusions were combined. This is not a log file; it is a formal causal graph that distinguishes between events that merely preceded the decision and events that actually caused it.

Constraints ensure rigor. A must_match constraint can require that every policy recommendation traces back to at least one verified data source. A never constraint can prohibit recommendations that lack a legal precedent check. These constraints are enforced at the architectural level, not as afterthought validations.

Law Enforcement

Criminal investigations increasingly involve multi-agent AI systems that cross-reference databases, analyze surveillance feeds, process forensic data, and correlate witness statements. The challenge is maintaining evidence chain integrity: every investigative conclusion must trace back to admissible evidence through a documented reasoning process.

PyRapide provides this by building a causal DAG of the investigation. When an agent flags a suspect, the DAG records exactly which evidence items -- which database records, which surveillance frames, which forensic results -- causally led to that conclusion.

# Identify the root evidence that triggered an investigation path
from pyrapide import queries

# Find the conclusion event that identified the suspect
conclusion = poset.find_by_name("InvestigationAgent.suspect_identified")[-1]

# Trace to the original evidence
root_evidence = queries.root_causes(poset, conclusion)

# root_evidence contains only the original, unprocessed evidence items
# that started the causal chain leading to suspect identification
for evidence in root_evidence:
    print(f"Original evidence: {evidence.name} — {evidence.payload}")

Military & Defense

Autonomous and semi-autonomous systems making time-critical decisions represent the highest-stakes application of multi-agent AI. Whether coordinating drone swarms, managing logistics under fire, or processing intelligence from multiple sensors, these systems must provide human operators with clear override points and complete decision transparency.

PyRapide makes every decision's causal chain visible. When an autonomous system recommends an engagement, the human operator can instantly see the full causal DAG: which sensor readings, which threat assessments, which rules of engagement evaluations, and which tactical calculations led to the recommendation.

# Ensure every tool invocation has a traced decision chain
from pyrapide.agent_templates import AgentPatterns

# full_tool_lifecycle() creates a constraint pattern ensuring that
# no tool (weapon system, communication system, navigation system)
# is invoked without a complete, traced decision chain
lifecycle_pattern = AgentPatterns.full_tool_lifecycle()

# This pattern verifies:
# 1. A sensor input or intelligence event exists as a root cause
# 2. A threat assessment event processes that input
# 3. A rules-of-engagement check event evaluates the assessment
# 4. A human authorization event (if required) precedes the action
# 5. The tool invocation event is causally linked to all of the above

Education

AI tutoring systems use multiple agents to assess student knowledge, recommend learning paths, select content, and adapt difficulty. When a student receives a recommendation -- "You should study Chapter 7 next" -- they (and their teachers and parents) deserve to know why.

PyRapide traces the complete causal chain behind every recommendation. Which assessment results demonstrated which knowledge gaps? Which content interactions revealed which learning preferences? Which performance patterns over time suggested which intervention?

# Understand why a student received a specific recommendation
from pyrapide import queries, CausalPredictor

# Trace the recommendation back to its causes
recommendation = poset.find_by_name("TutorAgent.path_recommendation")[-1]
causes = queries.backward_slice(poset, recommendation)

# See which assessment results contributed
assessments = [e for e in causes if e.name == "AssessmentAgent.score"]
for a in assessments:
    print(f"Assessment: {a.payload['topic']} — Score: {a.payload['score']}")

# Predict which interventions are most likely to improve outcomes
predictor = CausalPredictor(poset)
predictions = predictor.predict_outcomes(
    intervention_type="content_recommendation",
    student_profile=student_events
)
for pred in predictions:
    print(f"Intervention: {pred.action} — Predicted improvement: {pred.effect}")

Life Sciences

Drug interaction analysis, clinical trial monitoring, and molecular research all involve multi-agent systems cross-referencing vast datasets: molecular structures, patient records, published literature, genomic data, and trial results. When such a system flags a potential drug interaction or an anomalous trial result, researchers need to trace the exact data combinations that led to the flag.

PyRapide builds a causal DAG of the analysis process. When Agent A identifies a molecular similarity, Agent B finds a relevant case report, and Agent C correlates them with trial data, the DAG captures the precise causal chain that led to the conclusion.

# Identify unusual causal patterns in clinical trial data
from pyrapide import AnomalyDetector

detector = AnomalyDetector(poset)

# Detect causal patterns that deviate from expected trial behavior
anomalies = detector.detect(
    baseline_pattern="normal_trial_progression",
    sensitivity=0.95
)

for anomaly in anomalies:
    print(f"Anomaly: {anomaly.description}")
    print(f"Unusual causal chain: {anomaly.causal_path}")
    print(f"Deviation score: {anomaly.score}")

Healthcare: Nursing & Physicians

Modern healthcare increasingly involves multi-agent charting systems where nurses record observations, physicians enter orders, diagnostic AI interprets test results, and clinical decision support systems generate recommendations. When multiple agents contribute to a patient's chart, understanding which observation led to which decision becomes critical for patient safety.

PyRapide ensures every chart entry traces back to its source. A medication order traces to the clinical decision that authorized it, which traces to the diagnostic interpretation that motivated it, which traces to the test result that triggered it, which traces to the physician's order for the test, which traces to the nurse's observation that prompted the order.

# Show the downstream consequences of any single clinical decision
from pyrapide import queries

# A physician changes a medication dosage
dosage_change = poset.find_by_name("PhysicianAgent.order_modified")[-1]

# What are all the downstream consequences?
impact = queries.impact_set(poset, dosage_change)

# impact contains every event causally downstream of the dosage change:
# - Pharmacy verification events
# - Nursing administration events
# - Vital sign changes potentially caused by the new dosage
# - Any alerts triggered by those vital sign changes
for event in impact:
    print(f"Downstream: {event.name} at {event.timestamp}")
    print(f"  Payload: {event.payload}")

Patient Records & Charting Data

Electronic health records (EHRs) are among the most complex data systems in any industry. Multiple agents -- human and AI -- contribute to a single patient record: nurses enter vitals, physicians write notes, lab systems report results, pharmacy systems track medications, and billing systems code diagnoses.

PyRapide's causal DAGs provide complete data lineage for every entry in a patient record. When a medication order appears, the DAG traces the full chain: which symptom observation triggered which diagnostic test, which test produced which result, which result led to which clinical interpretation, and which interpretation justified which order.

# Trace the full causal chain behind a medication order
from pyrapide import queries

# Find the medication order event
med_order = poset.find_by_name("EHRAgent.medication_order")[-1]

# Full causal chain back to the original observation
chain = queries.backward_slice(poset, med_order)

# The chain reveals the complete lineage:
# 1. NurseAgent.symptom_observation (e.g., "patient reports chest pain")
# 2. PhysicianAgent.test_order (e.g., "order troponin levels")
# 3. LabAgent.result_reported (e.g., "troponin elevated at 0.8 ng/mL")
# 4. DiagnosticAI.interpretation (e.g., "consistent with acute MI")
# 5. PhysicianAgent.clinical_decision (e.g., "initiate anticoagulation")
# 6. EHRAgent.medication_order (e.g., "heparin drip per protocol")
for step in chain:
    print(f"Step: {step.name}")
    print(f"  Time: {step.timestamp}")
    print(f"  Data: {step.payload}")

# Prevent chart entries without traced origins
from pyrapide import never, Pattern

never(
    Pattern.match("EHRAgent.medication_order").where(
        lambda m: not any(
            e.name == "PhysicianAgent.clinical_decision"
            for e in m.events
        )
    ),
    name="no_untraced_orders",
    description="Every medication order must trace to a clinical decision"
)