DEV Community

JXIONG
JXIONG

Posted on

After AI Healthcare, Medical World Models May Be the Next Life-Science AI Platform

#ai #worldmodel

Subtitle: A system-design view of moving from risk prediction to intervention simulation**

Over the last decade, most AI healthcare narratives have been about helping machines see disease.

Computer vision systems detect lesions in medical images. Risk models estimate the probability of cardiovascular events, diabetes, readmission, or poor outcomes. Large language models summarize clinical notes, explain lab reports, and assist with medical text workflows.

These capabilities matter.

But most of them still answer one of two questions:

What is the current state?
What might happen in the future?
Enter fullscreen mode Exit fullscreen mode

Over the last few years, AI drug discovery has become one of the most visible frontiers in life-science AI. AI is now being used for target discovery, molecule generation, protein modeling, virtual screening, and trial optimization.

That is a major shift: AI is no longer only helping us identify disease; it is also helping us discover molecules.

But there may be another layer ahead.

The next life-science AI platform may not be only about identifying disease or discovering molecules. It may be about building systems that can represent an individual's biological state, encode possible interventions, simulate state-transition hypotheses, track evidence, and update decisions through longitudinal feedback.

That is the idea behind a medical world model.

A medical world model does not simply ask:

What is the patient's risk?
Enter fullscreen mode Exit fullscreen mode

It asks:

If we take this action, how might the patient's state change?
Why does the model believe that transition is plausible?
What evidence supports it?
What feedback should update the next decision?
Enter fullscreen mode Exit fullscreen mode

This article explains that idea from a system-design perspective.

1. Healthcare AI mostly started with recognition and prediction

Many healthcare AI systems can be simplified into three categories:

  1. Recognition
    • Is this image abnormal?
    • Is there a lesion?
    • Is this ECG pattern suspicious?
  2. Classification
    • Which subtype does this case belong to?
    • Which risk group is this patient in?
  3. Prediction
    • What is the probability of a future event?
    • How likely is readmission?
    • What is the estimated disease risk?

A typical medical prediction model looks like this:

risk = predict_risk(patient_state)
Enter fullscreen mode Exit fullscreen mode

For example:

patient_state = {
    "age": 52,
    "bmi": 29.1,
    "fasting_glucose": 6.2,
    "hba1c": 6.0,
    "blood_pressure": "138/86",
    "family_history": ["type_2_diabetes"],
    "sleep_duration": 5.8
}

risk = predict_diabetes_risk(patient_state)
Enter fullscreen mode Exit fullscreen mode

The output might be:

{
  "risk_level": "high",
  "estimated_5y_risk": 0.32
}
Enter fullscreen mode Exit fullscreen mode

This answers:

How high is the future risk?
Enter fullscreen mode Exit fullscreen mode

That is useful.

But real medical and health-management decisions do not stop there.

The next questions are usually:

  • What should be done first?
  • Should nutrition, exercise, sleep, medication review, or follow-up be prioritized?
  • Which intervention best matches the current mechanism hypothesis?
  • Which markers should be monitored?
  • If the expected change does not occur, was the action wrong, the mechanism wrong, or the feedback window wrong?

At that point, the system needs something most prediction models do not explicitly represent:

Action
Enter fullscreen mode Exit fullscreen mode

2. What does a medical world model model?

A medical world model is not a larger medical chatbot.

It is not an automatic treatment generator.

It is better understood as an auditable inference architecture built around five objects:

State       The current individual state
Action      A defined intervention or decision option
Transition  A hypothesis about how state may change after action
Evidence    The evidence chain supporting the hypothesis
Feedback    Real-world follow-up used to update the model
Enter fullscreen mode Exit fullscreen mode

A prediction model often looks like:

state -> outcome
Enter fullscreen mode Exit fullscreen mode

A medical world model looks more like:

state + action + evidence -> transition hypothesis -> feedback update
Enter fullscreen mode Exit fullscreen mode

In other words:

Prediction model:
    What may happen?

Medical world model:
    What may happen if we act?
Enter fullscreen mode Exit fullscreen mode

This is the shift from risk prediction to intervention simulation.

3. State: represent the individual before reasoning about action

The first step is not training a bigger model.

The first step is defining the state.

A simplified PatientState object might look like this:

from dataclasses import dataclass
from typing import Dict, List, Optional

@dataclass
class PatientState:
    demographics: Dict
    clinical_markers: Dict
    symptoms: List[str]
    lifestyle: Dict
    medications: List[str]
    history: Dict
    omics: Optional[Dict] = None
    wearable: Optional[Dict] = None
Enter fullscreen mode Exit fullscreen mode

Example:

patient_state = PatientState(
    demographics={
        "age": 52,
        "sex": "unspecified"
    },
    clinical_markers={
        "bmi": 29.1,
        "fasting_glucose": 6.2,
        "hba1c": 6.0,
        "triglycerides": 2.1,
        "hdl_c": 0.95,
        "blood_pressure": "138/86"
    },
    symptoms=[
        "fatigue",
        "post_meal_sleepiness"
    ],
    lifestyle={
        "sleep_hours": 5.8,
        "exercise_frequency_per_week": 1,
        "diet_pattern": "high_refined_carbohydrate",
        "stress_level": "high"
    },
    medications=[],
    history={
        "family_history": ["type_2_diabetes"],
        "previous_diagnosis": []
    }
)
Enter fullscreen mode Exit fullscreen mode

The goal is not to add endless fields.

The goal is to create a state representation that can support:

  • action selection;
  • evidence retrieval;
  • transition estimation;
  • safety checking;
  • feedback updates.

A state that cannot be referenced by actions or updated through feedback is not very useful for a world-model system.

4. Action: make interventions computable

Prediction models do not necessarily need actions.

Medical world models do.

The phrase "improve lifestyle" is not a good action object. It is too vague to execute, track, audit, or update.

A better approach is to encode interventions as structured objects:

@dataclass
class InterventionAction:
    action_id: str
    category: str
    description: str
    target_mechanism: List[str]
    intensity: str
    duration_weeks: int
    monitoring_markers: List[str]
    safety_notes: List[str]
Enter fullscreen mode Exit fullscreen mode

Example:

action = InterventionAction(
    action_id="nutrition_low_glycemic_8w",
    category="nutrition",
    description="8-week low-glycemic dietary adjustment with reduced refined carbohydrates",
    target_mechanism=[
        "postprandial_glucose_variability",
        "insulin_resistance",
        "weight_management"
    ],
    intensity="moderate",
    duration_weeks=8,
    monitoring_markers=[
        "fasting_glucose",
        "hba1c",
        "weight",
        "waist_circumference",
        "postprandial_glucose"
    ],
    safety_notes=[
        "not a medical prescription",
        "review with clinician if diabetes medication is used",
        "monitor hypoglycemia risk when relevant"
    ]
)
Enter fullscreen mode Exit fullscreen mode

This matters because a medical world model should not merely generate recommendations.

It should make each action:

  • describable;
  • executable;
  • trackable;
  • auditable;
  • reviewable;
  • feedback-compatible.

5. Transition: a hypothesis, not a treatment-effect promise

In ordinary engineering language, you may be tempted to write:

next_state = model.predict_next_state(state, action)
Enter fullscreen mode Exit fullscreen mode

In medicine, that can be misleading.

It sounds like the system is predicting individual treatment effects.

A safer and more accurate name is:

transition_hypothesis = estimate_transition_tendency(state, action)
Enter fullscreen mode Exit fullscreen mode

A transition object might look like:

@dataclass
class TransitionHypothesis:
    expected_direction: Dict
    mechanism_rationale: List[str]
    uncertainty_level: str
    time_window_weeks: int
    assumptions: List[str]
Enter fullscreen mode Exit fullscreen mode

Example:

transition = TransitionHypothesis(
    expected_direction={
        "fasting_glucose": "decrease_possible",
        "postprandial_glucose": "decrease_possible",
        "weight": "slight_decrease_possible",
        "energy_level": "may_improve"
    },
    mechanism_rationale=[
        "lower refined carbohydrate intake may reduce postprandial glucose excursion",
        "weight reduction may improve insulin sensitivity",
        "improved dietary pattern may reduce metabolic stress"
    ],
    uncertainty_level="moderate",
    time_window_weeks=8,
    assumptions=[
        "adequate adherence",
        "no major medication change",
        "baseline data quality is acceptable",
        "no unrecognized endocrine disorder"
    ]
)
Enter fullscreen mode Exit fullscreen mode

Notice what this does not say:

will cure
will reverse
will normalize
will improve with certainty
Enter fullscreen mode Exit fullscreen mode

Instead, it says:

decrease_possible
may_improve
transition tendency
Enter fullscreen mode Exit fullscreen mode

That distinction is essential.

A medical world model should generate mechanism-constrained transition hypotheses, not deterministic treatment promises.

6. Evidence: every transition needs an evidence chain

A transition without evidence is just a generated suggestion.

A medical world model needs an evidence object.

@dataclass
class EvidenceItem:
    source_type: str
    description: str
    strength: str
    url_or_reference: Optional[str] = None

@dataclass
class EvidenceChain:
    items: List[EvidenceItem]
    overall_strength: str
    limitations: List[str]
Enter fullscreen mode Exit fullscreen mode

Example:

evidence_chain = EvidenceChain(
    items=[
        EvidenceItem(
            source_type="clinical_guideline",
            description="Lifestyle modification is commonly recommended for metabolic risk management.",
            strength="high"
        ),
        EvidenceItem(
            source_type="mechanistic_evidence",
            description="Reduced refined carbohydrate intake may lower postprandial glucose excursions.",
            strength="moderate"
        ),
        EvidenceItem(
            source_type="individual_context",
            description="Patient reports high refined carbohydrate intake and low exercise frequency.",
            strength="contextual"
        )
    ],
    overall_strength="moderate",
    limitations=[
        "individual response may vary",
        "adherence is uncertain",
        "not a substitute for clinical evaluation"
    ]
)
Enter fullscreen mode Exit fullscreen mode

The evidence object should help answer:

  • Where does the reasoning come from?
  • How strong is the evidence?
  • What are the assumptions?
  • What is the uncertainty?
  • What are the clinical or safety boundaries?

Without this layer, a medical world model risks becoming a black-box recommendation engine.

7. Feedback: the model must update over time

A world model is not a one-shot answer generator.

It must support feedback.

@dataclass
class FollowUpFeedback:
    timepoint_weeks: int
    observed_markers: Dict
    adherence: Dict
    symptoms_change: Dict
    adverse_events: List[str]
Enter fullscreen mode Exit fullscreen mode

Example:

feedback = FollowUpFeedback(
    timepoint_weeks=8,
    observed_markers={
        "fasting_glucose": 5.8,
        "hba1c": 5.8,
        "weight": -2.1,
        "waist_circumference": -3.0
    },
    adherence={
        "diet": "medium",
        "exercise": "low",
        "sleep": "unchanged"
    },
    symptoms_change={
        "fatigue": "slightly_improved",
        "post_meal_sleepiness": "improved"
    },
    adverse_events=[]
)
Enter fullscreen mode Exit fullscreen mode

Then update the record:

def update_state_with_feedback(
    previous_state: PatientState,
    action: InterventionAction,
    transition: TransitionHypothesis,
    feedback: FollowUpFeedback
):
    audit_log = {
        "previous_state": previous_state,
        "action": action,
        "expected_transition": transition,
        "observed_feedback": feedback,
        "interpretation": None,
        "next_step": None
    }

    if feedback.adherence["diet"] == "medium":
        audit_log["interpretation"] = (
            "Partial improvement observed; adherence may limit effect size."
        )
        audit_log["next_step"] = (
            "Review action intensity and adherence barriers."
        )
    else:
        audit_log["interpretation"] = (
            "Feedback should be interpreted with caution."
        )
        audit_log["next_step"] = (
            "Collect more context before updating intervention plan."
        )

    return audit_log
Enter fullscreen mode Exit fullscreen mode

The key loop is:

observe -> act -> simulate -> monitor -> update
Enter fullscreen mode Exit fullscreen mode

From a platform perspective, this is important.

The next generation of medical AI may not be a single-use diagnostic tool. It may be a longitudinal feedback platform.

8. A minimal medical world-model workflow

A minimal workflow could look like this:

def medical_world_model_loop(patient_id: str):
    # 1. Observe state
    state = observe_patient_state(patient_id)

    # 2. Generate candidate actions
    candidate_actions = generate_candidate_actions(state)

    # 3. Safety filter
    safe_actions = []
    for action in candidate_actions:
        if pass_safety_gate(state, action):
            safe_actions.append(action)

    # 4. Estimate transitions
    transition_candidates = []
    for action in safe_actions:
        transition = estimate_transition_tendency(state, action)
        evidence = build_evidence_chain(state, action, transition)

        transition_candidates.append({
            "action": action,
            "transition": transition,
            "evidence": evidence
        })

    # 5. Human-in-the-loop review
    selected_action = clinician_or_expert_review(transition_candidates)

    # 6. Execute and monitor
    feedback = collect_follow_up_feedback(patient_id, selected_action)

    # 7. Update state and audit log
    updated_record = update_state_with_feedback(
        previous_state=state,
        action=selected_action,
        transition=selected_action["transition"],
        feedback=feedback
    )

    return updated_record
Enter fullscreen mode Exit fullscreen mode

The most important line is this:

selected_action = clinician_or_expert_review(transition_candidates)
Enter fullscreen mode Exit fullscreen mode

A medical world model should not bypass professional review.

Its safer positioning is:

hypothesis generation + decision support + audit trail
Enter fullscreen mode Exit fullscreen mode

Not:

automatic diagnosis or treatment
Enter fullscreen mode Exit fullscreen mode

9. Safety gate: boundaries must come before optimization

In medical systems, safety should not be an afterthought.

def pass_safety_gate(state: PatientState, action: InterventionAction) -> bool:
    # Example checks only. Not medical advice.
    contraindications = detect_contraindications(state, action)
    medication_conflicts = check_medication_conflicts(state, action)
    red_flags = detect_red_flags(state)

    if red_flags:
        return False

    if contraindications:
        return False

    if medication_conflicts:
        return False

    return True
Enter fullscreen mode Exit fullscreen mode

Example:

def detect_red_flags(state: PatientState) -> List[str]:
    red_flags = []

    if state.clinical_markers.get("fasting_glucose", 0) > 13.9:
        red_flags.append("very_high_glucose_requires_clinical_evaluation")

    if "chest_pain" in state.symptoms:
        red_flags.append("chest_pain_requires_urgent_evaluation")

    return red_flags
Enter fullscreen mode Exit fullscreen mode

The design principle is simple:

A medical AI system should not become more autonomous faster than it becomes auditable.
Enter fullscreen mode Exit fullscreen mode

10. Audit logs are not optional

A medical world model should leave an audit trail for every transition hypothesis.

@dataclass
class AuditLog:
    patient_id: str
    state_snapshot_id: str
    action_id: str
    transition_id: str
    evidence_chain_id: str
    reviewer: str
    decision: str
    uncertainty_level: str
    safety_notes: List[str]
    timestamp: str
Enter fullscreen mode Exit fullscreen mode

Example:

audit_log = AuditLog(
    patient_id="P001",
    state_snapshot_id="S20260521",
    action_id="nutrition_low_glycemic_8w",
    transition_id="T20260521_001",
    evidence_chain_id="E20260521_001",
    reviewer="human_expert",
    decision="approved_for_health_management_context",
    uncertainty_level="moderate",
    safety_notes=[
        "not medical diagnosis",
        "not treatment prescription",
        "clinical review required if symptoms worsen"
    ],
    timestamp="2026-05-21T17:00:00+08:00"
)
Enter fullscreen mode Exit fullscreen mode

Without audit logs, the system cannot answer:

  • Why was this action proposed?
  • What evidence supported it?
  • Which assumptions later failed?
  • Which feedback changed the next decision?
  • Where should responsibility and review occur?

This is where medical world models differ from ordinary generative AI applications.

11. Steerable world models: not control, but direction and feedback

A regular world model can simulate possible futures.

Medicine needs more than simulation.

It needs a way to define objectives, actions, boundaries, feedback metrics, and stop conditions.

That is the idea behind a steerable world model.

Steerable does not mean controlling the human body.

It means making the intervention loop explicit:

@dataclass
class SteeringInterface:
    objective: Dict
    allowed_actions: List[InterventionAction]
    safety_constraints: List[str]
    feedback_metrics: List[str]
    stop_conditions: List[str]
Enter fullscreen mode Exit fullscreen mode

Example:

steering = SteeringInterface(
    objective={
        "primary": "improve_metabolic_resilience",
        "secondary": ["reduce_glucose_variability", "improve_energy_level"]
    },
    allowed_actions=[
        "nutrition_adjustment",
        "exercise_adjustment",
        "sleep_management",
        "clinical_referral_when_needed"
    ],
    safety_constraints=[
        "no medication change without clinician",
        "stop if red flags appear",
        "avoid unsupported intervention claims"
    ],
    feedback_metrics=[
        "fasting_glucose",
        "postprandial_glucose",
        "weight",
        "waist_circumference",
        "symptom_score"
    ],
    stop_conditions=[
        "adverse_event",
        "red_flag_symptom",
        "data_quality_insufficient"
    ]
)
Enter fullscreen mode Exit fullscreen mode

For medical AI, steerability means:

  • objective;
  • action;
  • boundary;
  • evidence;
  • feedback;
  • stop condition;
  • human review.

Not autonomous control.

12. Why investors should pay attention to medical world models

The investment relevance is not that "medical world model" is a new buzzword.

The relevance is that it may connect several currently fragmented life-science AI markets.

1. It extends healthcare AI

Healthcare AI started with recognition, classification, and prediction.

Medical world models extend that into intervention simulation.

2. It complements AI drug discovery

AI drug discovery focuses on targets, molecules, and development workflows.

Medical world models focus on what happens when interventions meet individual states.

That can include drugs, but also nutrition, exercise, sleep, behavioral interventions, monitoring, and long-term care pathways.

3. It provides a framework for precision medicine

Precision medicine needs individualized state representation and decision logic.

Medical world models provide a structure for state, action, transition, evidence, and feedback.

4. It fits longevity medicine

Longevity medicine is not a one-time diagnosis.

It is longitudinal state management.

That makes it naturally aligned with state-action-transition-feedback loops.

5. It may become a platform layer

The platform opportunity is not a single model output.

It is a longitudinal infrastructure for:

  • state representation;
  • intervention encoding;
  • evidence tracking;
  • safety filtering;
  • expert review;
  • feedback collection;
  • model calibration.

That is why medical world models may represent a future life-science AI platform category rather than just another AI tool.

13. Why longevity medicine is a natural early use case

Longevity medicine deals with long-term state management rather than single-point diagnosis.

It involves:

  • multi-system aging;
  • metabolic and immune changes;
  • chronic low-grade inflammation;
  • sleep, stress, movement, and nutrition;
  • individual differences;
  • combined interventions;
  • periodic retesting;
  • N-of-1 feedback.

This is not just a classification problem.

It is a longitudinal loop:

while health_management_active:
    state = observe_longitudinal_state(user)
    actions = generate_intervention_candidates(state)
    transitions = estimate_transition_tendencies(state, actions)
    reviewed_plan = human_review(transitions)
    feedback = collect_longitudinal_feedback(reviewed_plan)
    update_model_state(state, reviewed_plan, feedback)
Enter fullscreen mode Exit fullscreen mode

In system terms:

longevity medicine = longitudinal state-action-transition-feedback problem
Enter fullscreen mode Exit fullscreen mode

That is why longevity tech, precision health, and functional medicine may become early application environments for medical world models.

14. A compact JSON representation

Here is a simplified JSON representation of a medical world-model record:

{
  "patient_state": {
    "state_id": "S20260521",
    "clinical_markers": {
      "bmi": 29.1,
      "fasting_glucose": 6.2,
      "hba1c": 6.0,
      "triglycerides": 2.1
    },
    "lifestyle": {
      "sleep_hours": 5.8,
      "exercise_frequency_per_week": 1,
      "diet_pattern": "high_refined_carbohydrate"
    },
    "risk_context": [
      "family_history_type_2_diabetes",
      "possible_insulin_resistance"
    ]
  },
  "candidate_action": {
    "action_id": "nutrition_low_glycemic_8w",
    "category": "nutrition",
    "duration_weeks": 8,
    "target_mechanism": [
      "postprandial_glucose_variability",
      "insulin_resistance"
    ],
    "monitoring_markers": [
      "fasting_glucose",
      "hba1c",
      "weight",
      "waist_circumference"
    ]
  },
  "transition_hypothesis": {
    "expected_direction": {
      "fasting_glucose": "decrease_possible",
      "postprandial_glucose": "decrease_possible",
      "weight": "slight_decrease_possible"
    },
    "uncertainty_level": "moderate",
    "time_window_weeks": 8
  },
  "evidence_chain": {
    "overall_strength": "moderate",
    "limitations": [
      "individual_response_varies",
      "adherence_uncertain",
      "not_a_treatment_prescription"
    ]
  },
  "safety_gate": {
    "requires_clinician_review": false,
    "red_flags": [],
    "notes": [
      "health_management_context_only",
      "not_medical_diagnosis"
    ]
  },
  "feedback_plan": {
    "timepoint_weeks": 8,
    "metrics": [
      "fasting_glucose",
      "hba1c",
      "weight",
      "waist_circumference",
      "symptom_score"
    ]
  }
}
Enter fullscreen mode Exit fullscreen mode

The point is not this exact schema.

The point is that a medical world model decomposes reasoning into inspectable objects.

15. Developer principles

Principle 1: Do not start with a chatbot

A medical world model should not begin with:

answer = llm.chat(user_question)
Enter fullscreen mode Exit fullscreen mode

It should begin with schemas:

state = define_state_schema()
action = define_action_schema()
transition = define_transition_schema()
evidence = define_evidence_schema()
feedback = define_feedback_schema()
Enter fullscreen mode Exit fullscreen mode

Principle 2: Do not frame transition as treatment-effect prediction

Avoid:

effect = predict_treatment_effect(state, action)
Enter fullscreen mode Exit fullscreen mode

Prefer:

hypothesis = estimate_transition_tendency(state, action, evidence)
Enter fullscreen mode Exit fullscreen mode

Principle 3: Evidence must be a first-class object

Avoid:

recommendation = generate_recommendation(state)
Enter fullscreen mode Exit fullscreen mode

Prefer:

recommendation = {
    "action": action,
    "transition_hypothesis": transition,
    "evidence_chain": evidence,
    "uncertainty": uncertainty,
    "safety_notes": safety_notes
}
Enter fullscreen mode Exit fullscreen mode

Principle 4: Human-in-the-loop should be core 

decision = human_expert_review(model_output)
Enter fullscreen mode Exit fullscreen mode

This should be part of the design, not an afterthought.

Principle 5: Feedback update is the product moat

If there is no feedback update, the system is not really a world model.

model_state = update_with_feedback(model_state, observed_feedback)
Enter fullscreen mode Exit fullscreen mode

16. From tool to infrastructure

Healthcare AI's first wave helped machines see disease.

AI drug discovery helped machines search molecular space.

Medical world models may help machines reason about interventions under uncertainty.

From an engineering perspective, the architecture is:

State
  + Action
  + Evidence
  -> Transition Hypothesis
  -> Feedback
  -> Calibration
Enter fullscreen mode Exit fullscreen mode

The value is not "automatic treatment."

The value is making medical reasoning:

  • representable;
  • auditable;
  • traceable;
  • feedback-driven;
  • calibratable;
  • reviewable by human experts.

For longevity medicine, precision health, functional medicine, and long-term health-management platforms, this architecture may be especially important.

Those fields do not need one-shot predictions.

They need longitudinal state-action-transition-feedback loops.

If healthcare AI's first value was to see disease, and AI drug discovery's value is to discover molecules, then medical world models may define the next stage:

simulate interventions,
track feedback,
and continuously calibrate individual biological states.
Enter fullscreen mode Exit fullscreen mode

That is why medical world models may become a next-generation life-science AI platform category.

References

  1. Ha, D., & Schmidhuber, J. Recurrent World Models Facilitate Policy Evolution. Advances in Neural Information Processing Systems 31, 2018. https://arxiv.org/abs/1803.10122
  2. LeCun, Y. A Path Towards Autonomous Machine Intelligence. OpenReview, 2022. https://openreview.net/forum?id=BZ5a1r-kVsf
  3. Yang, Y., Wang, Z.-Y., Liu, Q., Sun, S., Wang, K., Chellappa, R., Zhou, Z., Yuille, A., Zhu, L., Zhang, Y.-D., & Chen, J. Medical World Model: Generative Simulation of Tumor Evolution for Treatment Planning. arXiv:2506.02327, 2025. https://arxiv.org/abs/2506.02327
  4. Qazi, M. A., Nadeem, M., & Yaqub, M. Beyond Generative AI: World Models for Clinical Prediction, Counterfactuals, and Planning. arXiv:2511.16333, 2025. https://arxiv.org/abs/2511.16333
  5. Katsoulakis, E., Wang, Q., Wu, H., et al. Digital twins for health: a scoping review. npj Digital Medicine, 7, 77, 2024. https://doi.org/10.1038/s41746-024-01073-0
  6. Pearl, J., & Mackenzie, D. The Book of Why: The New Science of Cause and Effect. Basic Books, 2018.
  7. Xiong, J. World Models for Biomedicine: A Steerability Framework. Preprints.org, 2026. https://doi.org/10.20944/preprints202605.0366.v1
  8. Steerable World project: https://steerable.world

Top comments (0)