DEV Community: JXIONG

Why Systems Biology Is Not the Same as a Medical World Model

JXIONG — Thu, 21 May 2026 13:56:41 +0000

If you have worked with computational biology, multi-omics analysis, pathway modeling, biomedical knowledge graphs, or systems biology, the phrase medical world model may sound suspicious at first.

You might ask:

Isn't this just systems biology with a new name?

That is a fair question.

Life sciences have been modeling gene regulatory networks, signaling pathways, metabolic systems, disease mechanisms, and biological perturbations for decades. If a medical world model were only a rebranding of systems biology, digital twins, or large language models, it would not add much technical value.

But from a system-design perspective, the difference is not mainly about terminology.

It is about object boundaries.

A systems biology model often focuses on:

component -> relation -> pathway -> network -> mechanism

A medical world model needs to additionally represent:

state + action + evidence -> transition hypothesis -> feedback update

In other words:

systems biology helps us understand how biological systems work;
medical world models aim to reason about how an individual state may change under a defined action;
steerable medical world models further add objectives, constraints, safety gates, human review, feedback, and auditability.

This article explains the distinction from a developer's perspective.

1. Three model types, three engineering boundaries

A useful way to avoid confusion is to compare prediction models, systems biology models, and medical world models.

Model type	Core question	Main objects	Typical output	Engineering keywords
Prediction model	How high is the future risk?	features, labels	risk score, class, probability	classification / regression
Systems biology model	How does the biological system work?	genes, proteins, pathways, networks	mechanism, network dynamics	graph / ODE / network model
Medical world model	How may state change after an action?	state, action, transition, evidence, feedback	transition hypothesis, audit trail	state-action-feedback loop

A standard medical risk model may look like:

risk = predict_risk(patient_features)

A systems biology model may look like:

network_state = simulate_pathway_dynamics(
    pathway_graph,
    initial_conditions,
    perturbation
)

A medical world model is closer to:

transition = estimate_transition_hypothesis(
    state=current_patient_state,
    action=candidate_intervention,
    evidence=evidence_chain
)

feedback = collect_feedback(
    patient_id=patient_id,
    action=candidate_intervention,
    time_window_weeks=8
)

updated_state = update_state(
    previous_state=current_patient_state,
    action=candidate_intervention,
    transition=transition,
    feedback=feedback
)

The important difference is not that one model is more complex than another.

The difference is the modeling target:

feature prediction
    -> mechanism modeling
    -> action-conditioned transition reasoning

2. Systems biology can model perturbations, but action is not always a decision object

Systems biology is not action-free.

It can model:

gene knockout;
drug perturbation;
pathway activation or inhibition;
environmental change;
ODE-based dynamics;
network control;
multi-omics perturbation response.

So this statement would be wrong:

systems biology has no action
medical world models have action

A better distinction is:

Systems biology can model perturbations and responses. A medical world model needs to turn action into a structured decision object and place it inside an evidence, transition, feedback, safety, and audit loop.

In systems biology, a perturbation may be an input parameter:

result = simulate_network(
    graph=pathway_graph,
    perturbation={"gene_x": "knockout"}
)

In a medical world model, an action is not just a perturbation parameter. It must be executable, recordable, auditable, monitorable, and feedback-compatible.

For example:

from dataclasses import dataclass
from typing import List

@dataclass
class InterventionAction:
    action_id: str
    category: str
    description: str
    target_mechanisms: List[str]
    intensity: str
    duration_weeks: int
    monitoring_markers: List[str]
    safety_constraints: List[str]

Example:

action = InterventionAction(
    action_id="nutrition_low_glycemic_8w",
    category="nutrition",
    description="8-week low-glycemic dietary adjustment",
    target_mechanisms=[
        "postprandial_glucose_variability",
        "insulin_resistance",
        "weight_management"
    ],
    intensity="moderate",
    duration_weeks=8,
    monitoring_markers=[
        "fasting_glucose",
        "hba1c",
        "weight",
        "waist_circumference"
    ],
    safety_constraints=[
        "not a treatment prescription",
        "clinical review required if medication is involved",
        "stop or refer if red flags appear"
    ]
)

The engineering distinction is:

perturbation parameter != intervention action object

3. Systems biology often starts from a mechanism graph

A simplified systems biology model can be represented as a graph.

from dataclasses import dataclass
from typing import List

@dataclass
class BiologicalNode:
    node_id: str
    node_type: str  # gene, protein, metabolite, pathway, phenotype
    name: str

@dataclass
class BiologicalEdge:
    source: str
    target: str
    relation: str  # activates, inhibits, regulates, correlates_with
    evidence_strength: str

@dataclass
class MechanismGraph:
    nodes: List[BiologicalNode]
    edges: List[BiologicalEdge]

Example:

mechanism_graph = MechanismGraph(
    nodes=[
        BiologicalNode("n1", "pathway", "insulin_signaling"),
        BiologicalNode("n2", "phenotype", "glucose_variability"),
        BiologicalNode("n3", "phenotype", "fatigue")
    ],
    edges=[
        BiologicalEdge(
            source="n1",
            target="n2",
            relation="regulates",
            evidence_strength="moderate"
        ),
        BiologicalEdge(
            source="n2",
            target="n3",
            relation="associated_with",
            evidence_strength="low"
        )
    ]
)

This structure is valuable.

It helps represent:

mechanisms;
pathways;
regulatory relationships;
phenotype associations;
biological modules;
possible system-level interactions.

But it is not yet a full medical world model.

It still does not explicitly answer:

What is the current individual state?
What action may be taken?
How might state change after the action?
What evidence supports that transition?
What feedback window should be used?
How should the next cycle be updated if feedback differs from expectation?

That is where the world-model framing becomes useful.

4. A medical world model needs a State object

A medical world model starts with an individual state representation.

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

@dataclass
class PatientState:
    patient_id: str
    demographics: Dict
    clinical_markers: Dict
    lifestyle: Dict
    symptoms: List[str]
    medications: List[str]
    omics: Optional[Dict] = None
    wearable: Optional[Dict] = None
    mechanism_context: Optional[Dict] = None

Example:

state = PatientState(
    patient_id="P001",
    demographics={
        "age": 52,
        "sex": "unspecified"
    },
    clinical_markers={
        "bmi": 29.1,
        "fasting_glucose": 6.2,
        "hba1c": 6.0,
        "triglycerides": 2.1,
        "hdl_c": 0.95
    },
    lifestyle={
        "sleep_hours": 5.8,
        "exercise_frequency_per_week": 1,
        "diet_pattern": "high_refined_carbohydrate"
    },
    symptoms=[
        "fatigue",
        "post_meal_sleepiness"
    ],
    medications=[],
    mechanism_context={
        "possible_insulin_resistance": True,
        "possible_glucose_variability": True,
        "data_quality": "partial"
    }
)

The key principle is:

State should not be a data dump. It should be referenceable by actions, transitions, evidence, and feedback.

If a field cannot influence action selection, transition reasoning, safety filtering, or feedback updates, it may be noise rather than useful state.

5. Transition is not treatment-effect prediction

Developers may be tempted to write:

next_state = predict_next_state(state, action)

In medical settings, this is risky language.

It can sound like the model predicts individual treatment effects.

A safer and more precise abstraction is:

transition = estimate_transition_hypothesis(
    state=state,
    action=action,
    evidence=evidence_chain
)

That is: a transition hypothesis.

@dataclass
class TransitionHypothesis:
    expected_direction: Dict
    mechanism_rationale: List[str]
    uncertainty_level: str
    time_window_weeks: int
    assumptions: List[str]
    limitations: List[str]

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 excursions",
        "weight reduction may improve insulin sensitivity",
        "improved sleep may reduce metabolic stress"
    ],
    uncertainty_level="moderate",
    time_window_weeks=8,
    assumptions=[
        "adequate adherence",
        "no major medication change",
        "baseline data quality is acceptable"
    ],
    limitations=[
        "individual response may vary",
        "not a treatment effect prediction",
        "not a substitute for clinical judgment"
    ]
)

Notice the wording:

decrease_possible
may_improve
hypothesis
uncertainty
limitations

Not:

will decrease
will reverse
will cure

This distinction matters in medical AI.

A medical world model should not make deterministic treatment promises. It should produce mechanism-informed, evidence-bounded, uncertainty-aware transition hypotheses.

6. EvidenceChain: recommendations are not enough

If a system only outputs:

recommendation = "reduce refined carbohydrates and increase exercise"

it is not yet a medical world model.

A medical world model should explain:

why this action is proposed;
which mechanism it targets;
what evidence supports it;
what uncertainty remains;
where the safety boundary is.

A simple evidence chain can look like:

@dataclass
class EvidenceItem:
    source_type: str  # guideline, trial, mechanism, omics, individual_context
    description: str
    strength: str
    reference: str | None = None

@dataclass
class EvidenceChain:
    items: List[EvidenceItem]
    overall_strength: str
    uncertainty: str
    limitations: List[str]

Example:

evidence_chain = EvidenceChain(
    items=[
        EvidenceItem(
            source_type="mechanism",
            description="Reduced refined carbohydrate intake may reduce postprandial glucose excursions.",
            strength="moderate"
        ),
        EvidenceItem(
            source_type="individual_context",
            description="Current state includes high refined carbohydrate pattern and low exercise frequency.",
            strength="contextual"
        ),
        EvidenceItem(
            source_type="clinical_guideline",
            description="Lifestyle intervention is commonly recommended for metabolic risk management.",
            strength="high"
        )
    ],
    overall_strength="moderate",
    uncertainty="moderate",
    limitations=[
        "adherence is uncertain",
        "individual response may vary",
        "clinical review required when disease or medication is involved"
    ]
)

Engineering rule:

recommendation without evidence object = weak output
action + transition + evidence + feedback plan = stronger world-model output

7. Feedback: the system must update

A world model should not be a one-shot answer generator.

It should support feedback updates.

@dataclass
class FollowUpFeedback:
    patient_id: str
    action_id: str
    timepoint_weeks: int
    observed_markers: Dict
    adherence: Dict
    symptom_changes: Dict
    adverse_events: List[str]

Example:

feedback = FollowUpFeedback(
    patient_id="P001",
    action_id="nutrition_low_glycemic_8w",
    timepoint_weeks=8,
    observed_markers={
        "fasting_glucose": 5.8,
        "hba1c": 5.8,
        "weight_change_kg": -2.1,
        "waist_change_cm": -3.0
    },
    adherence={
        "nutrition": "medium",
        "exercise": "low",
        "sleep": "unchanged"
    },
    symptom_changes={
        "fatigue": "slightly_improved",
        "post_meal_sleepiness": "improved"
    },
    adverse_events=[]
)

Feedback then updates the record:

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

    if feedback.adherence.get("nutrition") == "medium":
        update_record["interpretation"] = (
            "Partial improvement observed; adherence may limit effect size."
        )
        update_record["next_step"] = (
            "Review adherence barriers and consider adjusting action intensity."
        )
    else:
        update_record["interpretation"] = (
            "Observed feedback should be interpreted with caution."
        )
        update_record["next_step"] = (
            "Collect more context before updating the transition hypothesis."
        )

    return update_record

If the system cannot update from feedback, it is closer to a recommendation engine than a world model.

8. Causal boundaries: action-conditioned reasoning is not correlation

Once a system asks:

if action A, then what may happen?

it enters causal territory.

The transition should not be only correlation:

transition = correlate(state_features, future_outcomes)

The system should explicitly track causal assumptions and uncertainty:

@dataclass
class CausalAssumption:
    assumption_id: str
    description: str
    possible_confounders: List[str]
    applicable_population: str
    evidence_level: str
    uncertainty: str

Example:

causal_assumption = CausalAssumption(
    assumption_id="CA001",
    description=(
        "Reducing refined carbohydrate intake may reduce postprandial glucose "
        "excursions in individuals with diet-related glucose variability."
    ),
    possible_confounders=[
        "medication_change",
        "physical_activity_change",
        "sleep_change",
        "stress_change",
        "baseline_disease_status"
    ],
    applicable_population="health-management context with mild metabolic risk",
    evidence_level="moderate",
    uncertainty="individual_response_varies"
)

This does not mean every implementation must ship a full causal inference engine.

It means:

If the system outputs action-conditioned transitions, it must record causal assumptions, applicability, uncertainty, and limitations.

Otherwise, transition hypotheses can easily become correlation-based extrapolations.

9. SafetyGate: medical systems need boundaries before optimization

A medical world model should not simply optimize for the most promising action.

It must first apply safety boundaries.

@dataclass
class SafetyGateResult:
    passed: bool
    red_flags: List[str]
    contraindications: List[str]
    required_review: List[str]
    notes: List[str]

Example:

def run_safety_gate(
    state: PatientState,
    action: InterventionAction
) -> SafetyGateResult:
    red_flags = []
    contraindications = []
    required_review = []

    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")

    if state.medications:
        required_review.append("medication_context_requires_clinician_review")

    passed = len(red_flags) == 0 and len(contraindications) == 0

    return SafetyGateResult(
        passed=passed,
        red_flags=red_flags,
        contraindications=contraindications,
        required_review=required_review,
        notes=[
            "not medical advice",
            "not a validated treatment planning system",
            "human review required in clinical context"
        ]
    )

Principle:

No safety gate, no medical world-model deployment.

10. AuditLog: every transition should leave a trace

A medical world model should be able to answer:

What was the state at the time?
Why was this action proposed?
What was the transition hypothesis?
What evidence supported it?
Who reviewed it?
Did feedback match the expectation?
If not, how was the next cycle updated?

A minimal audit log:

@dataclass
class AuditLog:
    record_id: str
    patient_id: str
    state_snapshot_id: str
    action_id: str
    transition_id: str
    evidence_chain_id: str
    safety_gate_id: str
    reviewer: str
    decision: str
    timestamp: str

Example:

audit_log = AuditLog(
    record_id="AUDIT_20260521_001",
    patient_id="P001",
    state_snapshot_id="STATE_20260521",
    action_id="nutrition_low_glycemic_8w",
    transition_id="TRANSITION_20260521_001",
    evidence_chain_id="EVIDENCE_20260521_001",
    safety_gate_id="SAFETY_20260521_001",
    reviewer="human_expert",
    decision="approved_for_health_management_context",
    timestamp="2026-05-21T20:00:00+08:00"
)

The goal is not to generate a better-sounding answer.

The goal is to make the reasoning process traceable, auditable, feedback-driven, and reviewable.

11. A minimal medical world-model loop

Putting the objects together:

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

    # 2. Retrieve mechanism context
    mechanism_context = retrieve_mechanism_context(state)

    # 3. Generate candidate actions
    candidate_actions = generate_candidate_actions(
        state=state,
        mechanism_context=mechanism_context
    )

    transition_candidates = []

    for action in candidate_actions:
        # 4. Safety gate first
        safety = run_safety_gate(state, action)

        if not safety.passed:
            continue

        # 5. Build evidence chain
        evidence = build_evidence_chain(
            state=state,
            action=action,
            mechanism_context=mechanism_context
        )

        # 6. Estimate transition hypothesis
        transition = estimate_transition_hypothesis(
            state=state,
            action=action,
            evidence=evidence
        )

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

    # 7. Human-in-the-loop review
    selected = human_expert_review(transition_candidates)

    # 8. Collect follow-up feedback
    feedback = collect_follow_up_feedback(
        patient_id=patient_id,
        action_id=selected["action"].action_id,
        time_window_weeks=selected["transition"].time_window_weeks
    )

    # 9. Update model state
    updated_record = update_world_model_state(
        previous_state=state,
        action=selected["action"],
        transition=selected["transition"],
        feedback=feedback
    )

    # 10. Write audit log
    audit_log = write_audit_log(
        state=state,
        selected=selected,
        feedback=feedback,
        updated_record=updated_record
    )

    return {
        "updated_record": updated_record,
        "audit_log": audit_log
    }

The workflow order matters:

state
  -> mechanism context
  -> candidate action
  -> safety gate
  -> evidence chain
  -> transition hypothesis
  -> human review
  -> feedback
  -> update
  -> audit log

That is the engineering difference between a mechanism graph and a medical world-model loop.

12. JSON example: one transition record

A simplified transition record may look like:

{
  "state": {
    "patient_id": "P001",
    "state_snapshot_id": "STATE_20260521",
    "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"
    },
    "mechanism_context": {
      "possible_insulin_resistance": true,
      "possible_glucose_variability": true,
      "data_quality": "partial"
    }
  },
  "action": {
    "action_id": "nutrition_low_glycemic_8w",
    "category": "nutrition",
    "duration_weeks": 8,
    "target_mechanisms": [
      "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,
    "limitations": [
      "individual_response_varies",
      "not_a_treatment_effect_prediction"
    ]
  },
  "evidence_chain": {
    "overall_strength": "moderate",
    "items": [
      {
        "source_type": "mechanism",
        "description": "Reduced refined carbohydrate intake may reduce postprandial glucose excursions."
      },
      {
        "source_type": "individual_context",
        "description": "Current lifestyle pattern includes high refined carbohydrate intake."
      }
    ]
  },
  "safety_gate": {
    "passed": true,
    "red_flags": [],
    "notes": [
      "not_medical_advice",
      "human_review_required_in_clinical_context"
    ]
  },
  "feedback_plan": {
    "timepoint_weeks": 8,
    "metrics": [
      "fasting_glucose",
      "hba1c",
      "weight",
      "waist_circumference",
      "symptom_score"
    ]
  }
}

This schema is not the point.

The point is that the reasoning becomes structured.

13. Developer principles

Principle 1: Do not start with a chatbot

Avoid starting with:

answer = llm.chat(user_question)

Start with objects:

state_schema = define_state_schema()
action_schema = define_action_schema()
transition_schema = define_transition_schema()
evidence_schema = define_evidence_schema()
feedback_schema = define_feedback_schema()

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

Avoid:

effect = predict_treatment_effect(state, action)

Prefer:

transition = estimate_transition_hypothesis(state, action, evidence)

Principle 3: A mechanism graph is not the full world model

mechanism_graph = build_mechanism_graph(omics_data)

This is useful, but not enough.

You still need:

action = define_intervention_action()
transition = estimate_transition_hypothesis(state, action, evidence)
feedback = collect_follow_up_feedback()

Principle 4: Evidence must be a first-class object

Avoid:

recommendation = generate_recommendation(state)

Prefer:

output = {
    "state": state,
    "action": action,
    "transition_hypothesis": transition,
    "evidence_chain": evidence_chain,
    "safety_gate": safety_gate,
    "feedback_plan": feedback_plan
}

Principle 5: Human-in-the-loop is core

A medical world model should not be designed as an automatic treatment system.

decision = human_expert_review(model_output)

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

Principle 6: No feedback, no strong world model

If the system cannot update:

updated_state = update_state(previous_state, action, feedback)

it is closer to a one-shot recommendation system than a medical world model.

14. A steerable medical world model

In this context, SteeraMed can be understood as a steerable biomedical world-model framework.

Its engineering focus is not automatic control of the human body.

It is the organization of these objects:

State
Action
Transition Hypothesis
Evidence Chain
Safety Gate
Human Review
Feedback
Audit Log

A simplified interface:

class SteerableMedicalWorldModel:
    def observe_state(self, patient_id):
        pass

    def generate_actions(self, state):
        pass

    def run_safety_gate(self, state, action):
        pass

    def build_evidence_chain(self, state, action):
        pass

    def estimate_transition(self, state, action, evidence):
        pass

    def request_human_review(self, candidates):
        pass

    def collect_feedback(self, selected_action):
        pass

    def update_model(self, state, action, feedback):
        pass

    def write_audit_log(self, record):
        pass

This is very different from a medical chatbot.

A chatbot can generate a plausible answer.

A medical world model should preserve the state, action, evidence, transition, feedback, and audit trail behind the answer.

15. Summary: mechanism layer vs action-simulation layer

Systems biology is essential.

It helps us understand biological networks, pathways, mechanisms, dynamics, and system-level regulation.

But from an engineering perspective, a systems biology model is usually not yet a complete medical world model.

A medical world model connects:

individual state
intervention action
mechanism-informed evidence
transition hypothesis
safety gate
human review
longitudinal feedback
audit log

The relationship can be summarized as:

Systems biology:
    mechanism understanding

Medical world model:
    mechanism-informed action simulation

Steerable medical world model:
    goal-directed, evidence-bounded, feedback-calibrated intervention reasoning

So the distinction is not about replacing systems biology.

It is about extending mechanism understanding into action-conditioned, evidence-bounded, feedback-calibrated reasoning.

That is why medical AI still needs medical world models, even in a field where systems biology is already powerful.

References

Kitano, H. Systems Biology: A Brief Overview. Science, 2002. https://doi.org/10.1126/science.1069492
Kitano, H. Computational systems biology. Nature, 2002. https://doi.org/10.1038/nature01254
Ideker, T., Galitski, T., & Hood, L. A new approach to decoding life: systems biology. Annual Review of Genomics and Human Genetics, 2001. https://doi.org/10.1146/annurev.genom.2.1.343
Barabási, A.-L., Gulbahce, N., & Loscalzo, J. Network medicine: a network-based approach to human disease. Nature Reviews Genetics, 2011. https://doi.org/10.1038/nrg2918
Noble, D. The Music of Life: Biology Beyond Genes. Oxford University Press, 2006.
Ha, D., & Schmidhuber, J. Recurrent World Models Facilitate Policy Evolution. NeurIPS, 2018. https://arxiv.org/abs/1803.10122
LeCun, Y. A Path Towards Autonomous Machine Intelligence. OpenReview, 2022. https://openreview.net/forum?id=BZ5a1r-kVsf
Pearl, J., & Mackenzie, D. The Book of Why: The New Science of Cause and Effect. Basic Books, 2018.
Katsoulakis, E., Wang, Q., Wu, H., et al. Digital twins for health: a scoping review. npj Digital Medicine, 2024. https://doi.org/10.1038/s41746-024-01073-0
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
Xiong, J. World Models for Biomedicine: A Steerability Framework. Preprints.org, 2026. https://doi.org/10.20944/preprints202605.0366.v1
SteeraMed project: https://SteeraMed.com
Steerable World project: https://steerable.world

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

JXIONG — Thu, 21 May 2026 10:32:55 +0000

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?

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?

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?

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:

Recognition
- Is this image abnormal?
- Is there a lesion?
- Is this ECG pattern suspicious?
Classification
- Which subtype does this case belong to?
- Which risk group is this patient in?
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)

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)

The output might be:

{
  "risk_level": "high",
  "estimated_5y_risk": 0.32
}

This answers:

How high is the future risk?

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

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

A prediction model often looks like:

state -> outcome

A medical world model looks more like:

state + action + evidence -> transition hypothesis -> feedback update

In other words:

Prediction model:
    What may happen?

Medical world model:
    What may happen if we act?

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

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": []
    }
)

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]

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"
    ]
)

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)

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)

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]

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"
    ]
)

Notice what this does not say:

will cure
will reverse
will normalize
will improve with certainty

Instead, it says:

decrease_possible
may_improve
transition tendency

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]

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"
    ]
)

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]

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=[]
)

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

The key loop is:

observe -> act -> simulate -> monitor -> update

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

The most important line is this:

selected_action = clinician_or_expert_review(transition_candidates)

A medical world model should not bypass professional review.

Its safer positioning is:

hypothesis generation + decision support + audit trail

Not:

automatic diagnosis or treatment

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

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

The design principle is simple:

A medical AI system should not become more autonomous faster than it becomes auditable.

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

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"
)

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]

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"
    ]
)

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)

In system terms:

longevity medicine = longitudinal state-action-transition-feedback problem

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"
    ]
  }
}

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)

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()

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

Avoid:

effect = predict_treatment_effect(state, action)

Prefer:

hypothesis = estimate_transition_tendency(state, action, evidence)

Principle 3: Evidence must be a first-class object

Avoid:

recommendation = generate_recommendation(state)

Prefer:

recommendation = {
    "action": action,
    "transition_hypothesis": transition,
    "evidence_chain": evidence,
    "uncertainty": uncertainty,
    "safety_notes": safety_notes
}

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

decision = human_expert_review(model_output)

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)

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

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.

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

References

Ha, D., & Schmidhuber, J. Recurrent World Models Facilitate Policy Evolution. Advances in Neural Information Processing Systems 31, 2018. https://arxiv.org/abs/1803.10122
LeCun, Y. A Path Towards Autonomous Machine Intelligence. OpenReview, 2022. https://openreview.net/forum?id=BZ5a1r-kVsf
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
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
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
Pearl, J., & Mackenzie, D. The Book of Why: The New Science of Cause and Effect. Basic Books, 2018.
Xiong, J. World Models for Biomedicine: A Steerability Framework. Preprints.org, 2026. https://doi.org/10.20944/preprints202605.0366.v1
Steerable World project: https://steerable.world

What Is a World Model, and Why Is It More Than Prediction?

JXIONG — Thu, 21 May 2026 00:38:09 +0000

Most medical AI systems today are still designed as prediction systems.

A typical pipeline looks like this:

data = collect_patient_data()
features = extract_features(data)
risk = model.predict(features)
return risk

This can be useful.

A prediction model can answer questions such as:

What is the estimated risk of a disease?
Does an image contain an abnormal finding?
Which risk group does this person belong to?
What is the probability of a future clinical event?

But a world model asks a different question.

A prediction model asks:

future = predict(state)

A world model asks:

next_state = simulate_transition(state, action)

In other words:

Prediction asks: what may happen next?

A world model asks: what may happen if we take a specific action?

That difference matters a lot in medicine.

Medicine is not only about recognizing risk. It is also about deciding what to do under uncertainty.

The Minimal Structure of a World Model

A simplified world model can be described with five objects:

State       What is the system like now?
Action      What can be done?
Transition  How may the system change after the action?
Objective   What direction are we trying to move toward?
Feedback    What did we observe after the action?

A very small abstraction could look like this:

class WorldModel:
    def observe_state(self, system):
        pass

    def define_action(self, action_input):
        pass

    def simulate_transition(self, state, action):
        pass

    def collect_feedback(self, system, action):
        pass

    def update(self, state, action, feedback):
        pass

This is already different from a simple predictive model.

A predictive model can work without an explicit action object.

A world model cannot.

If there is no action, there is no action-conditioned transition.

Why Medical AI Needs More Than Risk Prediction

Many medical AI systems are good at recognition and prediction:

image classification;
risk scoring;
disease detection;
prognosis estimation;
anomaly detection;
population stratification.

But many real medical and health-management problems are not just classification problems.

They are action problems.

For example:

Should an intervention be considered?
Which variable should be monitored first?
What evidence supports the expected change?
What feedback should be collected?
If the result is different from expected, what should be updated?

These are not just prediction questions. They require a system to reason about state, action, transition, evidence, and feedback.

That is where the idea of a medical world model becomes useful.

A Prediction Model vs. a Medical World Model

A prediction model may look like this:

class PredictionModel:
    def predict_risk(self, patient_data):
        features = self.extract_features(patient_data)
        risk_score = self.model.predict(features)
        return risk_score

It maps data to a risk score.

A medical world model needs a different structure:

class MedicalWorldModel:
    def simulate_transition(self, state, action, evidence):
        if not self.safety_gate(state, action):
            return {
                "status": "blocked",
                "reason": "Safety gate failed. Human review required."
            }

        transition = self.transition_model.estimate(
            state=state,
            action=action,
            evidence=evidence
        )

        return {
            "status": "hypothesis_generated",
            "state": state,
            "action": action,
            "expected_transition": transition,
            "evidence": evidence,
            "disclaimer": "Hypothesis-generating only. Not medical advice."
        }

The output is not a treatment recommendation.

It is a transition hypothesis.

That distinction is critical.

State: Do Not Reduce a Person to a Risk Score

A risk score may be useful:

{
  "cardiovascular_risk": 0.23
}

But it is not enough for a world model.

A world model needs a richer representation of state.

Example schema:

{
  "subject_id": "anonymous_001",
  "timestamp": "2026-05-20",
  "metabolic_state": {
    "fasting_glucose": 5.6,
    "hba1c": 5.7,
    "fasting_insulin": 12.4,
    "triglycerides": 1.8
  },
  "inflammation_state": {
    "hs_crp": 2.1
  },
  "lifestyle_state": {
    "sleep_duration": 6.2,
    "weekly_exercise_minutes": 90,
    "diet_pattern": "high_refined_carbohydrate"
  },
  "risk_context": {
    "family_history": ["type_2_diabetes"],
    "medications": [],
    "known_conditions": []
  }
}

This is only an illustrative schema, not a clinical standard.

In a real system, every state variable should have:

source;
unit;
timestamp;
measurement context;
missing-value handling;
data-quality metadata;
uncertainty annotation.

A simple Python representation might look like this:

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

@dataclass
class HealthState:
    subject_id: str
    timestamp: str
    biomarkers: Dict[str, Any]
    lifestyle: Dict[str, Any]
    symptoms: Dict[str, Any]
    medications: List[str]
    context: Dict[str, Any]
    data_quality: Dict[str, Any]

For a medical world model, state representation is not a preprocessing detail.

It is the foundation.

Action: Interventions Must Become Computable Objects

In a chatbot, an intervention might appear as natural language:

Improve sleep, exercise more, and eat better.

That is not enough for a world model.

A world model needs computable action objects.

Example:

{
  "action_id": "increase_zone2_exercise",
  "type": "lifestyle",
  "target": "weekly_exercise_minutes",
  "change": {
    "from": 90,
    "to": 150
  },
  "duration": "12_weeks",
  "monitoring": [
    "resting_heart_rate",
    "sleep_quality",
    "fasting_glucose"
  ],
  "safety_notes": [
    "requires clinician review if known cardiovascular disease exists"
  ]
}

Python representation:

@dataclass
class MedicalAction:
    action_id: str
    action_type: str
    target: str
    parameters: Dict[str, Any]
    duration: str
    monitoring: List[str]
    safety_notes: List[str]

In medicine, an action could be:

a medication change;
a lifestyle intervention;
a monitoring plan;
a nutrition strategy;
a sleep intervention;
an exercise protocol;
a follow-up test;
a referral;
a decision to wait and observe.

The key is that actions should be explicit, parameterized, time-bounded, and auditable.

Evidence: Transitions Should Be Evidence-Bound

A medical world model should not freely hallucinate transitions.

Every transition hypothesis should be bound to evidence.

A minimal evidence object:

{
  "evidence_id": "evidence_001",
  "claim": "Increasing weekly aerobic exercise may improve insulin sensitivity in selected metabolic-risk populations.",
  "evidence_type": [
    "clinical_guideline",
    "peer_reviewed_study",
    "mechanistic_rationale"
  ],
  "strength": "moderate",
  "applicability": {
    "population_match": "partial",
    "condition_match": "partial",
    "uncertainty": "individual response may vary"
  },
  "limitations": [
    "not a personalized treatment prediction",
    "requires safety screening",
    "effect size depends on baseline state and adherence"
  ]
}

A simple evidence builder:

@dataclass
class EvidenceItem:
    evidence_id: str
    claim: str
    evidence_type: List[str]
    strength: str
    applicability: Dict[str, Any]
    limitations: List[str]

class EvidenceBuilder:
    def build(self, state: HealthState, action: MedicalAction):
        evidence_items = self.retrieve_relevant_evidence(state, action)
        filtered = self.filter_by_applicability(evidence_items, state)
        return filtered

    def retrieve_relevant_evidence(self, state, action):
        # In production, this should query curated knowledge bases,
        # clinical guidelines, systematic reviews, or trusted literature indexes.
        return []

    def filter_by_applicability(self, evidence_items, state):
        # Filter by population, context, condition, safety boundary,
        # measurement quality, and uncertainty.
        return evidence_items

A useful rule:

Do not generate advice. Generate evidence-bound transition hypotheses.

Transition: Hypothesis, Not Promise

In a medical world model, a transition should not be framed as a promise.

Bad framing:

This intervention will improve the outcome.

Better framing:

Given the current state and evidence constraints, this action may produce the following state changes, with uncertainty.

A transition object:

@dataclass
class TransitionHypothesis:
    from_state: HealthState
    action: MedicalAction
    expected_changes: Dict[str, Any]
    time_window: str
    evidence: List[EvidenceItem]
    uncertainty: Dict[str, Any]
    safety_flags: List[str]

Example output:

{
  "expected_changes": {
    "weekly_exercise_minutes": {
      "direction": "increase",
      "expected_from": 90,
      "expected_to": 150
    },
    "insulin_sensitivity": {
      "direction": "potential_improvement",
      "confidence": "low_to_moderate"
    },
    "fasting_glucose": {
      "direction": "possible_decrease",
      "confidence": "uncertain"
    }
  },
  "time_window": "8_to_12_weeks",
  "uncertainty": {
    "adherence": "unknown",
    "baseline_variability": "high",
    "measurement_noise": "moderate"
  },
  "safety_flags": [
    "screen cardiovascular risk before increasing exercise intensity"
  ]
}

Implementation sketch:

class TransitionModel:
    def estimate(self, state, action, evidence):
        expected_changes = self.estimate_expected_changes(
            state=state,
            action=action,
            evidence=evidence
        )

        uncertainty = self.estimate_uncertainty(
            state=state,
            action=action,
            evidence=evidence
        )

        safety_flags = self.check_safety_flags(state, action)

        return TransitionHypothesis(
            from_state=state,
            action=action,
            expected_changes=expected_changes,
            time_window=action.parameters.get("time_window", "unknown"),
            evidence=evidence,
            uncertainty=uncertainty,
            safety_flags=safety_flags
        )

The name matters.

Use TransitionHypothesis, not TreatmentPlan.

Safety Gate: Medical World Models Must Be Safety-First

A medical world model should not simulate all actions freely.

Before transition simulation, there should be a safety gate.

class SafetyGate:
    def check(self, state: HealthState, action: MedicalAction):
        checks = [
            self.check_contraindications(state, action),
            self.check_required_human_review(state, action),
            self.check_action_intensity(state, action),
            self.check_data_quality(state),
        ]

        return all(checks)

    def check_contraindications(self, state, action):
        # Placeholder only.
        # Production systems require curated medical rules and human review.
        return True

    def check_required_human_review(self, state, action):
        # Some actions should never be autonomous.
        return True

    def check_action_intensity(self, state, action):
        return True

    def check_data_quality(self, state):
        return True

Then:

def simulate_medical_transition(state, action):
    if not safety_gate.check(state, action):
        return {
            "status": "blocked",
            "reason": "Safety gate failed. Human review required."
        }

    evidence = evidence_builder.build(state, action)
    transition = transition_model.estimate(state, action, evidence)

    return transition

A useful design principle:

medical_world_model = safety_first + evidence_bound + feedback_calibrated

Feedback: Without Feedback, It Is Not a World Model

A world model should not be a one-shot answer generator.

It should support a loop:

Observe state → Define action → Simulate transition → Collect feedback → Update model

Pseudo-code:

def world_model_loop(subject, action):
    state_t0 = observe_state(subject)

    evidence = build_evidence_chain(state_t0, action)

    transition_hypothesis = simulate_transition(
        state=state_t0,
        action=action,
        evidence=evidence
    )

    feedback = collect_feedback(
        subject=subject,
        action=action,
        time_window=transition_hypothesis.time_window
    )

    updated_state = update_model(
        previous_state=state_t0,
        action=action,
        hypothesis=transition_hypothesis,
        feedback=feedback
    )

    return updated_state

Feedback can include:

repeated biomarkers;
symptoms;
wearable trends;
adherence records;
adverse events;
clinician review;
patient-reported outcomes;
environmental or lifestyle changes.

Feedback object:

{
  "feedback_id": "feedback_001",
  "action_id": "increase_zone2_exercise",
  "time_window": "12_weeks",
  "observations": {
    "weekly_exercise_minutes": 145,
    "fasting_glucose": 5.4,
    "sleep_duration": 6.5,
    "subjective_energy": "improved"
  },
  "adherence": "partial",
  "adverse_events": [],
  "notes": "Interpret carefully; multiple concurrent changes existed."
}

Update logic:

class FeedbackUpdater:
    def update(self, previous_state, action, hypothesis, feedback):
        comparison = self.compare_expected_vs_observed(
            expected=hypothesis.expected_changes,
            observed=feedback["observations"]
        )

        return {
            "previous_state": previous_state,
            "action": action,
            "hypothesis": hypothesis,
            "feedback": feedback,
            "comparison": comparison,
            "update_reason": self.infer_update_reason(comparison)
        }

Without feedback, the system cannot calibrate.

Audit Log: Every Transition Should Be Traceable

For medical AI, auditability is not optional.

A transition should have an audit trail:

{
  "audit_id": "audit_001",
  "timestamp": "2026-05-20T23:00:00+08:00",
  "state_version": "state_v1",
  "action_version": "action_v1",
  "evidence_version": "evidence_v1",
  "transition_version": "transition_v1",
  "model_version": "world_model_v0.1",
  "human_review": {
    "required": true,
    "status": "pending"
  },
  "disclaimer": "Hypothesis-generating only. Not a treatment recommendation."
}

Audit logger:

class AuditLogger:
    def log_transition(self, state, action, evidence, transition):
        return {
            "state": state,
            "action": action,
            "evidence": evidence,
            "transition": transition,
            "model_version": self.get_model_version(),
            "human_review_required": True,
            "disclaimer": "Hypothesis-generating only. Not medical advice."
        }

For medical world models, audit logs are part of the core architecture.

A Minimal Medical World Model

Putting the pieces together:

class MinimalMedicalWorldModel:
    def __init__(
        self,
        safety_gate,
        evidence_builder,
        transition_model,
        feedback_updater,
        audit_logger
    ):
        self.safety_gate = safety_gate
        self.evidence_builder = evidence_builder
        self.transition_model = transition_model
        self.feedback_updater = feedback_updater
        self.audit_logger = audit_logger

    def run(self, state, action):
        if not self.safety_gate.check(state, action):
            return {
                "status": "blocked",
                "message": "Safety gate failed. Human review required."
            }

        evidence = self.evidence_builder.build(state, action)

        transition = self.transition_model.estimate(
            state=state,
            action=action,
            evidence=evidence
        )

        audit_log = self.audit_logger.log_transition(
            state=state,
            action=action,
            evidence=evidence,
            transition=transition
        )

        return {
            "status": "hypothesis_generated",
            "transition": transition,
            "audit_log": audit_log
        }

    def update_with_feedback(self, previous_state, action, transition, feedback):
        return self.feedback_updater.update(
            previous_state=previous_state,
            action=action,
            hypothesis=transition,
            feedback=feedback
        )

Usage:

state = observe_state(subject)
action = define_action(intervention)

result = medical_world_model.run(state, action)

if result["status"] == "hypothesis_generated":
    feedback = collect_feedback(subject, action)

    updated = medical_world_model.update_with_feedback(
        previous_state=state,
        action=action,
        transition=result["transition"],
        feedback=feedback
    )

The loop is:

State → Action → Evidence → Transition → Audit → Feedback → Update

Where SteeraMed Fits

SteeraMed can be understood as a steerable biomedical world model framework.

In developer terms, it is closer to:

state-action-transition-evidence-feedback architecture

than to:

a chatbot that gives medical advice

The goal is not to automate treatment decisions.

The goal is to make biomedical AI systems more:

state-aware;
action-explicit;
evidence-bound;
feedback-calibrated;
safety-gated;
auditable;
human-reviewable.

This is especially relevant for long-term health and longevity medicine, where the problem is not a single prediction task but longitudinal state management under uncertainty.

Developer Takeaways

1. Do not start with a chatbot

A chatbot interface may be useful later, but it should not be the core architecture.

Start with state representation.

state = observe_state(subject)

2. Do not stop at risk prediction

Risk prediction is useful, but it is not a world model.

risk = predict(state)

is not enough.

3. Make actions explicit

Without explicit actions, there is no action-conditioned transition.

next_state = simulate(state, action)

4. Treat transitions as hypotheses

A medical transition is not a promise.

transition = generate_hypothesis(state, action, evidence)

5. Build evidence chains

A transition without evidence is not acceptable in medical AI.

evidence = build_evidence_chain(state, action)

6. Add safety gates before simulation

Do not simulate unsafe or unsupported actions.

if not safety_gate.check(state, action):
    require_human_review()

7. Close the loop with feedback

Without feedback, the model cannot calibrate.

model.update(feedback)

8. Log everything

Every state, action, evidence item, transition, feedback signal, and model version should be traceable.

audit_logger.log(state, action, evidence, transition, feedback)

Final Thought

A medical world model is not a larger prediction model.

It is a system architecture for reasoning about:

state + action + evidence + transition + feedback

under uncertainty.

For developers, the key shift is this:

Do not just build systems that predict what may happen.

Build systems that can represent state, encode actions, simulate evidence-bound transitions, collect feedback, and remain auditable.

That is the difference between prediction and a world model.

References and Project Links

Ha, D., & Schmidhuber, J. Recurrent World Models Facilitate Policy Evolution. Advances in Neural Information Processing Systems 31, 2018. https://papers.nips.cc/paper/7512-recurrent-world-models-facilitate-policy-evolution; arXiv version: https://arxiv.org/abs/1803.10122
LeCun, Y. A Path Towards Autonomous Machine Intelligence. OpenReview, 2022. https://openreview.net/forum?id=BZ5a1r-kVsf
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; project page: https://yijun-yang.github.io/MeWM/
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
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
Emmert-Streib, F., Parkkila, S., Laubenbacher, R., et al. The role of digital twins in P4 medicine: A paradigm for modern healthcare. npj Digital Medicine, 8, 735, 2025. https://doi.org/10.1038/s41746-025-02115-x
Xiong, J. World Models for Biomedicine: A Steerability Framework. Preprints.org, 2026. https://doi.org/10.20944/preprints202605.0366.v1
SteeraMed project: https://SteeraMed.com
Steerable World project: https://steerable.world

Medical AI Doesn’t Just Need Bigger Models. It Needs an ImageNet for State Transitions

JXIONG — Tue, 19 May 2026 00:15:48 +0000

Whoever builds the “state–intervention–transition” dataset for biomedicine may define the next generation of medical AI infrastructure.

Author: Jianghui Xiong

Medical AI is moving beyond classification, risk prediction, and question answering.

The next frontier is not just:


sample → label

or:


question → answer

It is:


state + action → next state

In other words:


current biological state + intervention → future biological state

To build real biomedical world models, we need more than bigger models. We need something analogous to ImageNet — not for images, but for biological state transitions.

I will call this idea, for now:


Biomedical TransitionNet

A shared infrastructure for recording, standardizing, and evaluating:


baseline biological state

- intervention
- follow-up biological state
- mechanism evidence
- uncertainty

This article explains why such an infrastructure is needed, why it matters, and why it is scientifically difficult.

It does not claim that a complete biomedical world model already exists.

1. ImageNet was not just a dataset. It was infrastructure.

When people talk about the deep learning revolution in computer vision, they often mention AlexNet, VGG, ResNet, and other neural network architectures.

That is correct, but incomplete.

One of the most important enabling factors was ImageNet.

ImageNet was not merely a large collection of images. Its deeper value was that it gave computer vision a shared coordinate system:

a common task,
a common label hierarchy,
common training and test data,
common benchmarks,
and a way to compare progress across models and institutions.

Before ImageNet, many computer vision systems were difficult to compare because they were trained and evaluated on different datasets. ImageNet helped the field converge around shared evaluation.

That is why ImageNet became much more than a database. It became research infrastructure.

Medical AI may now need something similar.

But not an image dataset.

Medicine needs an ImageNet for state transitions.

2. Medical AI has many models, but not enough transition data

Today, we already have many types of medical AI systems:

medical large language models,
medical question-answering systems,
radiology models,
pathology models,
omics foundation models,
virtual cell models,
digital twin systems,
clinical decision support tools,
AI drug discovery platforms.

These are important.

But if we think the future of medical AI is only “a bigger medical chatbot”, we may miss the real challenge.

Medicine is not only about answering questions.

Medicine is about understanding and changing biological trajectories.

A clinician does not only ask:


What disease does this patient have?

They also ask:


Why is this biological state happening?

What is driving deterioration?

Which mechanisms are actionable?

Which intervention may shift the trajectory?

How should the response be measured?

What if the expected response does not happen?

What if an adverse response appears?

These are not just language problems.

They are state transition problems.

Most medical AI today is still closer to:


sample → label

or:


question → answer

But biomedical world models require something closer to:


state + action → next state

That is the key shift.

3. What is a biomedical world model?

In AI, a world model is usually understood as an internal model that helps an agent simulate how the environment changes after an action.

A simple abstraction is:


current state + action → future state

In robotics, this may mean:


robot pose + motor command → next scene state

In autonomous driving, it may mean:


traffic scene + driving action → future traffic scene

In biomedicine, the analogous formulation would be:


biological state + intervention → future biological state

This could apply at multiple scales:


cell state + perturbation → cellular response

tissue state + treatment → tissue response

patient state + intervention → follow-up state

A biomedical world model should therefore not be understood as a medical chatbot.

It is not merely:


medical text in → medical text out

A more meaningful biomedical world model would combine:


state representation

- intervention representation
- transition modeling
- mechanism evidence
- uncertainty estimation
- feedback correction

That is much harder than ordinary medical QA.

And it requires a different kind of data.

4. Why medicine needs its own ImageNet

In computer vision, a basic supervised learning unit can often be simplified as:


image + label

For biomedical world models, the basic unit should look more like:


baseline state + action + follow-up state

Or mathematically:


S(t) + A → S(t + Δt)

Where:


S(t)       = biological state before intervention

A          = action or intervention

S(t + Δt)  = biological state after intervention

Δt         = time interval

This is fundamentally different from a static medical database.

A biomedical world model does not only need:

medical images,
electronic health records,
omics profiles,
drug-target databases,
clinical notes,
literature graphs.

Those are useful, but insufficient.

It needs structured longitudinal data describing:


what the biological state was,

what action was taken,

what changed afterward,

over what time scale,

with what evidence,

and with what uncertainty.

This is why medicine needs something like a Biomedical TransitionNet.

Not a direct copy of ImageNet.

A new infrastructure designed for biological state transitions.

5. What should one data unit look like?

A conventional supervised learning sample may look like:


x → y

Examples:


image → diagnosis label

clinical note → ICD code

genomic variant → risk category

A biomedical world-model sample should look more like:


state_before

- intervention
- state_after
- time_interval
- evidence_chain
- uncertainty

A simplified schema might look like this:


{

"baseline_state": {

"molecular": "...",

"clinical": "...",

"phenotype": "...",

"lifestyle": "...",

"context": "..."

},

"action": {

"type": "...",

"dose": "...",

"frequency": "...",

"duration": "...",

"mechanism": "..."

},

"follow_up_state": {

"molecular": "...",

"clinical": "...",

"phenotype": "...",

"adverse_events": "..."

},

"transition": {

"direction": "...",

"magnitude": "...",

"time_scale": "...",

"confidence": "..."

},

"evidence_chain": {

"target": "...",

"pathway": "...",

"biomarker": "...",

"phenotype": "...",

"validation": "..."

}

}

This is obviously simplified.

But the principle matters:

A biomedical world model should learn not only:


what this sample is

but:


how this biological system changed after a defined intervention

6. Five layers of a biomedical ImageNet

If we want to build an ImageNet-like infrastructure for biomedical world models, it should include at least five layers.

6.1 State representation

The first question is:


What is the biological state?

A patient state is not just a diagnosis label.

Terms such as:


diabetes

hypertension

aging

inflammation

fatigue

frailty

are useful, but they are high-level descriptions.

A real biological state may include:

genome,
DNA methylation,
transcriptome,
proteome,
metabolome,
immune state,
inflammatory state,
organ function,
microbiome,
sleep,
activity,
diet,
medication history,
environmental exposure,
clinical background.

A simplified representation may be:


individual_state =

molecular_state

- pathway_state
- organ_state
- phenotype_state
- lifestyle_context
- clinical_context

Without a state representation, a biomedical world model does not know what it is simulating.

6.2 Action ontology

A world model needs actions.

In medicine, actions are complex.

They may include:

drugs,
supplements,
diet,
exercise,
sleep intervention,
stress management,
cell therapy,
gene therapy,
regenerative medicine,
combination therapy,
N-of-1 personalized intervention.

Even a drug intervention requires many parameters:


drug name

dose

frequency

route

duration

combination

adherence

contraindications

adverse events

Exercise intervention also requires:


type

intensity

frequency

duration

heart-rate zone

recovery condition

baseline fitness

If actions are not standardized, the model cannot learn meaningful transitions.

6.3 Transition record

The core of a biomedical world model is the transition:


before → after

Examples:


inflammatory state before intervention → inflammatory state after intervention

DNA methylation age before intervention → DNA methylation age after intervention

metabolic state before intervention → metabolic state after intervention

tumor state before treatment → tumor state after treatment

Without follow-up measurement, there is no transition.

Without transition, there is no world model.

Many medical datasets are still one-time measurements:


one-time measurement

Biomedical world models need:


longitudinal measurement

6.4 Evidence chain

A medical model should not only output a probability.

If a model says:


This intervention may help.

That is not enough.

It should also answer:


Which targets are involved?

Which pathways are affected?

Which abnormal state does this address?

Which biomarkers can validate the response?

Which evidence comes from experiments?

Which evidence comes from clinical data?

Which part is only model inference?

Which risks should be monitored?

In medicine, prediction alone is not sufficient.

A safer output should look more like:


prediction + mechanism + validation + uncertainty

This is especially important because medical AI should not become an uninspectable black box.

6.5 Benchmark task

ImageNet helped computer vision because different models could be compared on shared tasks.

Biomedical world models need benchmarks too.

Possible benchmark tasks include:

cellular perturbation response prediction,
gene expression response after drug perturbation,
tumor state simulation after treatment,
metabolic biomarker response prediction,
inflammatory state transition prediction,
aging-related biomarker transition prediction,
N-of-1 intervention response direction prediction.

But the metrics cannot be copied directly from image classification.

Useful metrics may include:


directional accuracy

mechanistic consistency

biomarker validation

uncertainty calibration

risk awareness

cross-context generalization

This is much harder than top-1 accuracy.

But medicine requires it.

7. Related progress: promising, but still early

To be scientifically careful, we should not pretend that complete biomedical world models already exist.

They do not.

But several related directions are emerging.

7.1 ImageNet as an infrastructure analogy

ImageNet and ILSVRC showed how large-scale, standardized datasets and benchmarks can accelerate a field.

However, ImageNet is a benchmark for image classification and detection.

It is not equivalent to what biomedicine needs.

Here, ImageNet is used only as an infrastructure analogy.

The biomedical version must be longitudinal, dynamic, intervention-aware, and mechanism-sensitive.

7.2 World Models in AI

Ha and Schmidhuber’s World Models is a representative work in AI world modeling.

Its key idea is that an agent can learn an internal model of the environment and use it to simulate future states.

Medicine cannot directly copy this setting.

A human body is not a game environment.

Clinical intervention cannot be freely explored by trial and error.

But the abstraction:


state + action → future state

is still useful for thinking about medical AI.

7.3 Virtual cells and perturbation response

Arc Institute’s State model is a recent example of virtual-cell modeling.

It aims to predict how cells respond to drugs, cytokines, or genetic perturbations. Public descriptions indicate that State was trained on large-scale observational and perturbational single-cell data.

This is important because it directly touches the pattern:


cell state + perturbation → cellular response

However, State is primarily a cellular-level model.

It should not be confused with a complete patient-level biomedical world model.

7.4 Medical World Model for tumor evolution

Recent work using the term Medical World Model, such as MeWM, explores generative simulation of tumor evolution under treatment conditions.

This is relevant because it moves medical AI from static recognition toward treatment-conditioned disease dynamics.

But this direction is still early.

It should not be interpreted as a general solution to biomedical world modeling.

7.5 Digital twins and virtual physiological systems

Long before today’s AI world-model terminology, fields such as computational physiology, systems biology, virtual physiological systems, and digital twins already tried to connect biological structure, mechanism, dynamics, and measurable outputs.

That tradition matters.

A good biomedical world model should not be just a black-box predictor.

It should connect:


state

mechanism

dynamic change

measurement

feedback

Today’s biomedical world models can be seen as an extension of this older systems-modeling tradition into the era of AI, multi-omics, real-world data, and large-scale computation.

8. Why steerability matters

A biomedical world model that only predicts is not enough.

A model may predict that a patient’s risk is increasing.

But medicine needs more than that.

It needs to ask:


Which state can be measured?

Which abnormality can be explained?

Which intervention can be described?

Which transition can be tested?

Which deviation can be traced?

Which failure can be corrected?

This is why I emphasize steerability.

Going forward, I will use the name:


SteeraMed: A Steerable Biomedical World Model

Website:


https://SteeraMed.com

The earlier preprint name was:


SEWO / Steerable Medicine World Model

or in Chinese:


可驾驭医学世界模型

Whenever I mention SEWO / 可驾驭医学世界模型, it should be understood together with the new unified naming:


SteeraMed: A Steerable Biomedical World Model

The idea behind SEWO / SteeraMed is that biomedical world models should not only pursue predictive accuracy. They should also support:

state definition,
intervention description,
transition hypothesis,
mechanism audit,
deviation tracing,
uncertainty inspection,
expert steering,
and iterative correction.

The related ideas were introduced in the preprint:


World Models for Biomedicine: A Steerability Framework

and are also presented at:


https://steerable.world

Important clarification:

SEWO / SteeraMed is not a clinically validated treatment system.

It is not a medical device.

It is better understood as a structural framework and evidence-chain design principle for future biomedical world models.

The key question is not only:


Can the model predict?

but:


Can researchers and clinicians inspect, question, correct, and steer the model within clearly defined boundaries?

9. Why longevity medicine may be one entry point

Biomedical world models could start from many areas:

oncology,
cardiovascular disease,
metabolic disease,
immunology,
neurodegeneration,
drug discovery,
virtual cells,
longevity medicine.

Longevity medicine is not the only entry point.

But it is an interesting one.

Why?

9.1 Aging is a continuous state

Aging is not a single disease label.

It is a continuous, multi-system biological process involving:

inflammation,
metabolism,
immunity,
epigenetics,
mitochondrial function,
proteostasis,
stem-cell exhaustion,
cellular senescence,
organ function decline.

That makes it naturally suitable for state modeling.

9.2 Longevity medicine requires repeated measurement

Longevity medicine is not a one-time diagnostic event.

It depends on repeated measurement over time.

A useful intervention must be evaluated through:


baseline state → intervention → follow-up state

This is exactly the structure needed for biomedical world modeling.

9.3 Interventions are diverse

Longevity-related interventions may include:

diet,
exercise,
sleep,
supplements,
drugs,
cell therapy,
regenerative medicine,
stress management,
environmental exposure management.

This provides a rich action space.

9.4 Individual responses vary

The same intervention may produce different responses in different people.

That means longevity medicine cannot rely only on average effects.

It needs N-of-1 style transition data:


individual state → intervention → individual transition

Each well-structured N-of-1 intervention can be seen as a small world-model experiment.

10. Engineering implications

From an engineering perspective, the biomedical ImageNet is not just a dataset.

It is a data infrastructure problem.

It requires:

data collection,
data standardization,
multimodal integration,
time-series modeling,
intervention encoding,
causal confounding control,
privacy protection,
benchmark design,
safety boundaries,
evidence-chain tracking.

A simplified loop may look like:


measure state

↓

standardize state representation

↓

record intervention

↓

measure follow-up state

↓

construct transition sample

↓

train / evaluate world model

↓

generate testable hypothesis

↓

repeat and correct

This is not a static dataset.

It is a data flywheel.

11. Main challenges

This is scientifically and technically difficult.

Some of the main challenges include:

11.1 Biological state is complex

A human state cannot be compressed into one label.

We need ways to represent multi-omics, clinical metrics, imaging, lifestyle, symptoms, environmental exposure, and medical history as computable state variables.

11.2 Interventions are hard to standardize

Drugs, exercise, diet, sleep, supplements, and cell therapies all have complex parameters.

Without action standardization, transition learning will be noisy.

11.3 Follow-up data is scarce

Most medical data is not collected as structured pre/post intervention transition data.

This requires new data collection workflows.

11.4 Causal confounding is serious

In the real world, people often change many things at once:


diet

exercise

sleep

medication

supplements

stress

Attributing a state change to one factor is difficult.

This requires careful study design and statistical methods.

11.5 Safety and ethics are central

A biomedical world model cannot freely experiment like a game-playing agent.

Any intervention-related model must clearly distinguish:


research hypothesis

health-management suggestion

clinical decision support

medical recommendation

validated therapy

Clinical use would require prospective validation, safety evaluation, ethical review, regulatory review where applicable, and professional oversight.

11.6 Open standards and business incentives may conflict

If everything is closed, the field cannot build shared benchmarks.

If everything is open, companies may lack incentives to invest.

A practical ecosystem will need a balance among:


open benchmarks

privacy protection

commercial incentives

scientific collaboration

12. A minimal viable direction

A biomedical ImageNet should not begin by trying to simulate the entire human body.

A more realistic path is to start with minimal viable tasks.

Examples:

cellular perturbation response prediction,
tumor state change after treatment,
metabolic biomarker response prediction,
inflammatory state transition prediction,
DNA methylation age transition,
N-of-1 longevity intervention tracking.

A minimal task should define:


1. state variables
2. intervention variables
3. follow-up time
4. transition metrics
5. benchmark task
6. safety boundary

Start narrow.

Make it measurable.

Make it repeatable.

Make it auditable.

Then scale.

13. Whoever defines state, action, and transition may define the field

Medical AI will still need better models.

But bigger models alone cannot solve the problem of biomedical state transition learning.

The scarce asset is the infrastructure that allows models to learn:


how life systems change after intervention

Future platform-level medical AI companies may not be the ones with the largest language models.

They may be the ones that can build the strongest data flywheel:


measure biological state

standardize interventions

record follow-up changes

construct mechanism evidence chains

evaluate transition models

repeat

Whoever defines state defines what medical AI can see.

Whoever defines action defines how medical AI understands intervention.

Whoever defines transition defines how medical AI learns biological change.

Whoever defines the benchmark defines how the field measures progress.

Conclusion

ImageNet helped machines learn to see the world.

A biomedical ImageNet should help AI learn how life responds to intervention.

That does not mean replacing clinicians.

It means building a scientific infrastructure where models can learn:


how states form

how interventions act

how systems transition

how evidence is validated

The next decade of medical AI may not be limited by model size alone.

It may be limited by the lack of a shared infrastructure for biological state transitions.

That is the real opportunity.

References

Deng J, Dong W, Socher R, Li LJ, Li K, Fei-Fei L.

ImageNet: A Large-Scale Hierarchical Image Database. CVPR. 2009.

https://ieeexplore.ieee.org/document/5206848
Russakovsky O, Deng J, Su H, et al.

ImageNet Large Scale Visual Recognition Challenge. International Journal of Computer Vision. 2015.

https://arxiv.org/abs/1409.0575
ImageNet official website.

https://www.image-net.org/
Ha D, Schmidhuber J.

World Models. 2018.

https://worldmodels.github.io/
Arc Institute.

Arc Institute’s first virtual cell model: State.

https://arcinstitute.org/news/virtual-cell-model-state
Predicting cellular responses to perturbation across diverse contexts with State. bioRxiv. 2025.

https://www.biorxiv.org/content/10.1101/2025.06.26.661135v1
Yang Y, Wang ZY, Liu Q, et al.

Medical World Model: Generative Simulation of Tumor Evolution for Treatment Planning. arXiv.

https://arxiv.org/abs/2506.02327
IEEE Transactions on Biomedical Engineering.

Digital Twins / AI World Models.

https://www.embs.org/tbme/research-highlights/digital-twins-ai-world-models/
Acosta JN, Falcone GJ, Rajpurkar P, Topol EJ.

Multimodal biomedical AI. Nature Medicine. 2022.

https://www.nature.com/articles/s41591-022-01981-2
Xiong J.

World Models for Biomedicine: A Steerability Framework. Preprints.org. 2026.

https://www.preprints.org/manuscript/202605.0366

DOI: https://doi.org/10.20944/preprints202605.0366.v1
SteeraMed: A Steerable Biomedical World Model.

https://steerable.world

Disclaimer

This article is for research, technical, and industry discussion only.

It is not medical advice, diagnostic advice, or treatment advice.

Any biomedical world model intended for clinical use would require prospective validation, safety evaluation, ethical review, regulatory review where applicable, and professional clinical oversight.

Beyond Medical AI and AI Drug Discovery: Why Biomedicine Needs World Models

JXIONG — Mon, 18 May 2026 04:37:14 +0000

Over the past decade, AI in medicine has mostly moved through two major waves.

The first wave was medical AI.

It helped machines read, structure, summarize, and predict from medical data:

radiology image recognition
clinical note extraction
risk prediction
medical question answering
triage support
clinical documentation
patient record summarization

The second wave is AI drug discovery.

It tries to accelerate the discovery of intervention tools:

target discovery
molecular generation
protein structure prediction
virtual screening
toxicity prediction
preclinical optimization
drug-target interaction modeling

Both waves are important. Both will continue to matter.

But medicine has a deeper problem.

Medicine does not only ask:

What disease does this patient have?

Or:

Can we find a molecule that might affect this pathway?

Medicine ultimately asks:

If we intervene in this living system, will the patient’s trajectory actually change in a safe, explainable, and verifiable way?

That is the problem biomedical world models are beginning to address.

This article is a developer-oriented view of what a biomedical world model might be, why it matters, and why it must be built very differently from a chatbot or a standard prediction model.

Important disclaimer: biomedical world models are still an early research direction. The systems discussed here should be understood as hypothesis-generating, research-support, and decision-support frameworks — not validated clinical decision systems, not medical advice, and not substitutes for physicians, clinical trials, or regulatory review.

1. The missing layer in medical AI

Most current medical AI systems are good at perception, extraction, or prediction.

They answer questions like:


What does this image show?

What diagnosis is likely?

What is the patient’s risk?

What does this clinical note contain?

What happened in this hospitalization?

AI drug discovery answers a different question:


Can we find a molecule, target, protein interaction, or intervention candidate faster?

But there is a third question that is much harder:


If we apply this intervention to this patient or patient subgroup,

how might the biological and clinical trajectory change over time?

That is not just a prediction problem.

It is an intervention problem.

And intervention problems are harder because they require more than correlation. They require some combination of:

longitudinal patient state modeling
causal reasoning
counterfactual comparison
biological mechanism constraints
uncertainty estimation
feedback from real-world follow-up
auditability

A conventional risk model may say:


This patient has a high probability of disease progression.

A biomedical world model should help ask:


If we intervene now, does the trajectory change?

Compared with what counterfactual?

Through what mechanism?

With what uncertainty?

How will we verify it?

That is a very different engineering problem.

2. What is a biomedical world model?

In AI, a world model usually refers to a model that learns how an environment changes and uses that internal model for prediction, planning, or simulation.

In robotics, a world model may learn how an agent’s actions change the physical environment.

In games, it may learn how the game state evolves after each move.

In medicine, the analogy is tempting — but dangerous if taken too literally.

A human body is not a closed, fully observable, deterministic simulation environment. It is noisy, multi-scale, adaptive, heterogeneous, and only partially measured.

So a biomedical world model should not be understood as a complete digital human.

A safer definition is:

A biomedical world model is a computational framework that models how biological or clinical states may evolve over time under different interventions, constrained by data, mechanisms, counterfactual reasoning, uncertainty, and real-world feedback.

It is not simply a bigger medical LLM.

It is not just a risk calculator.

It is not a magic simulator of the entire body.

It is better understood as a framework for organizing:


state → intervention → trajectory → feedback → evidence

3. A minimal architecture

A biomedical world model needs more than one model.

A useful architecture may include at least seven layers.


[1] Patient / biological state representation

[2] Intervention representation

[3] Transition model

[4] Counterfactual engine

[5] Mechanism constraints

[6] Feedback and calibration loop

[7] Audit and uncertainty layer

Let’s unpack each layer.

4. Layer 1: State representation

The first problem is representing the current state.

In medicine, “state” is not just a diagnosis code.

A useful state representation may include:

clinical history
laboratory results
imaging features
medications
symptoms
genomics
transcriptomics
proteomics
metabolomics
methylation profiles
immune status
functional measurements
lifestyle variables
wearable data
longitudinal follow-up

In software terms, the model needs a structured representation of:


{

"patient_state": {

"clinical": {},

"molecular": {},

"functional": {},

"behavioral": {},

"temporal_history": {}

}

}

The hard part is that many of these fields are missing, noisy, biased, or measured using different platforms.

So state representation is not just an embedding problem. It is also a data quality, normalization, uncertainty, and clinical context problem.

5. Layer 2: Intervention representation

A world model must represent actions.

In medicine, actions are interventions.

Examples:


drug A

dose change

surgery

radiotherapy

nutrition plan

exercise intervention

sleep intervention

behavioral intervention

combination therapy

watchful waiting

A biomedical world model must distinguish between:


current state

intervention

post-intervention trajectory

Otherwise, it is only modeling natural history or observational risk.

A simplified schema might look like:


{

"intervention": {

"type": "drug",

"agent": "example_drug",

"dose": "low",

"duration": "12 weeks",

"target_pathway": "inflammation",

"expected_direction": "reduce inflammatory signaling"

}

}

But even this is simplified.

Real interventions involve adherence, timing, dose-response, patient heterogeneity, combination effects, and adverse events.

6. Layer 3: Transition modeling

The transition model asks:


Given state S and intervention A,

what future state S' might occur?

In notation:


S_t + A_t → S_t+1

For medicine, this is the core challenge.

The transition may involve:

short-term biomarker changes
delayed clinical outcomes
adverse effects
compensatory biological responses
organ-level changes
behavioral changes
disease progression or regression
treatment resistance

A naive predictive model might estimate:


P(outcome | current state)

A biomedical world model should move toward:


P(future state | current state, intervention, mechanism, context)

That is a much harder target.

7. Layer 4: Counterfactual reasoning

The most important clinical questions are often counterfactual:


What if we do nothing?

What if we intervene earlier?

What if we reduce the dose?

What if we choose another treatment?

What if the patient follows the plan only partially?

This is where standard machine learning can easily fail.

Observational medical data is full of confounding.

Patients who receive a treatment are not randomly selected. Physicians prescribe treatments based on severity, comorbidities, risk, access, and many unrecorded factors.

So a model trained only on historical associations may learn treatment patterns rather than treatment effects.

A biomedical world model therefore needs causal thinking.

It does not necessarily mean every system must implement a full formal causal graph. But it does mean developers must stop treating intervention modeling as ordinary next-token prediction or ordinary supervised learning.

At minimum, the system should ask:


What is the comparison?

What is the counterfactual?

What assumptions are being made?

What confounders may exist?

What evidence supports the causal claim?

8. Layer 5: Mechanism constraints

Medicine is not only data fitting.

A model that predicts something biologically impossible is not useful, even if it looks statistically plausible.

Biomedical world models need constraints from:

pathways
molecular mechanisms
pharmacology
physiology
clinical guidelines
disease natural history
known biomarkers
known safety boundaries

This does not mean we can manually encode all biology. We cannot.

But it does mean that mechanism-aware modeling is safer than purely black-box extrapolation, especially when the system is used to reason about interventions.

A world model should be able to explain:


Why is this intervention expected to change this state?

Which mechanism is assumed?

Which biomarkers should move first?

Which outcome would count as evidence?

What would falsify the hypothesis?

That last question is critical.

If a model cannot be wrong in any clear way, it cannot be scientifically useful.

9. Layer 6: Feedback and calibration

A biomedical world model should not stop after generating a prediction.

It needs a feedback loop.


prediction → follow-up measurement → comparison → calibration

For example:


The model expects inflammation markers to decrease after 8 weeks.

Follow-up data shows no change.

Now what?

Possible explanations:

the initial state was mischaracterized
the intervention was not followed
the assumed mechanism was wrong
the patient subgroup was wrong
the dosage was insufficient
the biomarker was not appropriate
the model extrapolated beyond its valid domain

This is where a world model becomes more than a prediction engine.

It becomes a framework for failure diagnosis.

That matters because in medicine, knowing why a model failed may be as important as knowing what it predicted.

10. Layer 7: Auditability and uncertainty

A biomedical world model should not produce false certainty.

It should express:

confidence
uncertainty
evidence strength
data limitations
assumptions
missing variables
out-of-distribution warnings
whether the output is hypothesis-level or decision-level

A useful system should distinguish between:


Supported by strong clinical evidence

Supported by mechanistic plausibility

Supported by weak observational data

Generated as a hypothesis only

Outside validated scope

This is especially important for medicine.

In consumer apps, a wrong recommendation may be annoying.

In healthcare, a wrong recommendation may harm a patient.

11. Why this matters for longevity medicine

Longevity medicine is a useful example because aging and chronic disease are trajectory problems.

Blood glucose, inflammation, immune function, muscle function, sleep, cognition, metabolism, and epigenetic markers all change over time.

A single test is only a snapshot.

The real question is:


Is the health trajectory improving?

For example, a biological age score may go down.

That sounds good.

But scientifically, it does not automatically mean:


better function

lower disease risk

longer lifespan

clinical benefit

A more rigorous model should ask:


Do multiple biomarkers move coherently?

Does function improve?

Does risk decrease?

Is the effect sustained?

Is there evidence of over-intervention?

Can follow-up validate the expected trajectory?

This is where weak biomedical world models may appear first.

Not complete simulations of the human body, but bounded systems that model specific aspects of health trajectories under defined interventions.

For example:


methylation + metabolism + functional measures + lifestyle + follow-up

Such systems should be used for research support or hypothesis generation, not as proof of clinical benefit.

12. Recent research signals

Some recent work points in this direction, although the field is still early.

One example is Medical World Model: Generative Simulation of Tumor Evolution for Treatment Planning, an arXiv preprint from 2025. It explores the idea of simulating tumor evolution after treatment decisions, moving beyond static image recognition toward post-treatment state simulation.

Another example is EHRWorld: A Patient-Centric Medical World Model for Long-Horizon Clinical Trajectories, an arXiv preprint from 2026. It explores long-horizon clinical trajectory modeling using electronic health records.

A related direction is SurvivEHR, a time-to-event foundation model for multiple long-term conditions from primary care electronic health records, published in npj Digital Medicine in 2026.

These works do not mean biomedical world models are clinically mature.

They mean the field is beginning to move from:


recognition and prediction

toward:


simulation, trajectory modeling, and intervention reasoning

That is a major shift.

13. Where SteeraMed fits

SteeraMed: A Steerable Biomedical World Model is a framework-level exploration of this direction.

Website:


https://SteeraMed.com

The core idea is that a biomedical world model should not only predict.

It should be steerable.

That means clinicians or researchers should be able to guide the model with meaningful directional inputs, such as:


reduce inflammation

improve metabolic resilience

avoid immune suppression

preserve muscle function

minimize adverse effects

But steerability does not mean arbitrary control.

It means the system should connect:


state representation

intervention direction

mechanism constraints

counterfactual reasoning

feedback calibration

auditability

A steerable biomedical world model should answer questions like:


What is the current state?

What intervention direction is being tested?

What mechanism is assumed?

What trajectory is expected?

What evidence would support it?

What evidence would falsify it?

Where is the uncertainty?

This is why steerability may be more important than raw prediction accuracy.

In medicine, the key question is not only:


Can the model predict the future?

It is:


Can we safely and transparently test whether an intervention changes the future?

14. What developers should not build

If you are building in this space, here are some traps to avoid.

Trap 1: A medical chatbot pretending to be a world model

A chatbot that explains diseases is not a world model.

A world model must represent state, intervention, time, feedback, and uncertainty.

Trap 2: A risk model pretending to simulate interventions

A risk model may predict probability under the status quo.

That does not mean it can estimate what happens after treatment.

Trap 3: A correlation engine pretending to be causal

Medical datasets contain confounding.

If your model cannot reason about counterfactuals, do not claim it estimates intervention effects.

Trap 4: A biomarker dashboard pretending to show health improvement

A biomarker change is not automatically a clinical benefit.

The model must connect biomarkers to function, symptoms, risk, or outcomes.

Trap 5: A black box pretending to be clinically trustworthy

In medicine, opacity is not a feature.

Auditability matters.

15. A developer checklist

If someone claims to be building a biomedical world model, ask:


1. What state does the model represent?
2. What interventions can it represent?
3. Does it model time explicitly?
4. What counterfactual is being compared?
5. What mechanisms constrain the prediction?
6. How is uncertainty expressed?
7. How is feedback incorporated?
8. What would falsify the model output?
9. What data domain is it validated on?
10. Is it a research tool, decision-support tool, or clinical product?

If these questions cannot be answered, it is probably not a biomedical world model.

It may still be useful.

But it should not be marketed as a world model.

16. Final thought

Medical AI helped us read medical data.

AI drug discovery helps us search for intervention tools.

Biomedical world models may help us ask a deeper question:


What happens after we intervene?

That question is central to medicine.

But it is also scientifically difficult.

Biomedical world models should therefore begin as cautious, auditable, weakly bounded systems for hypothesis generation and evidence organization — not as autonomous clinical decision machines.

The goal is not to replace doctors.

The goal is not to simulate the entire human body.

The goal is to build better computational frameworks for connecting:


state

intervention

mechanism

trajectory

counterfactual

feedback

evidence

If this direction matures, the next generation of biomedical AI may move beyond prediction and discovery toward something more important:

helping us test how to safely, explainably, and verifiably change health trajectories.

That is the real promise of biomedical world models.

References

U.S. Food and Drug Administration. Considerations for the Use of the Plausible Mechanism Framework to Develop Individualized Therapies that Target Specific Genetic Conditions with Known Biological Cause. Draft Guidance, February 2026.
U.S. Food and Drug Administration. FDA Launches Framework for Accelerating Development of Individualized Therapies for Ultra-Rare Diseases. FDA News Release, February 23, 2026.
Prasad V, Makary MA. FDA’s New Plausible Mechanism Pathway. New England Journal of Medicine. 2025;393(23):2365–2367. doi:10.1056/NEJMsb2512695.
Yang Y, Wang ZY, Liu Q, et al. Medical World Model: Generative Simulation of Tumor Evolution for Treatment Planning. arXiv:2506.02327, 2025.
Mu L, Huang X, Gu Y, Qin S, Zhang S, Zhang X. EHRWorld: A Patient-Centric Medical World Model for Long-Horizon Clinical Trajectories. arXiv:2602.03569, 2026.
Gadd C, Gokhale K, Acharya A, et al. SurvivEHR: a competing risks, time-to-event foundation model for multiple long-term conditions from primary care electronic health records. npj Digital Medicine. 2026. doi:10.1038/s41746-026-02709-z.
Schölkopf B, Locatello F, Bauer S, Ke NR, Kalchbrenner N, Goyal A, Bengio Y. Toward Causal Representation Learning. Proceedings of the IEEE. 2021;109(5):612–634.
Pearl J. Causality: Models, Reasoning, and Inference. Cambridge University Press.
Hernán MA, Robins JM. Causal Inference: What If. Chapman & Hall/CRC.
SteeraMed: A Steerable Biomedical World Model. https://SteeraMed.com
Xiong J, et al. World Models for Biomedicine: A Steerability Framework. Preprints.org, 2026. doi:10.20944/preprints202605.0366.v1.

Medical World Models: Why Healthcare AI Needs Steerability, Not Just Harness Engineering

JXIONG — Sun, 17 May 2026 13:41:10 +0000

Large language models, RAG systems, AI agents, and tool-calling workflows are rapidly entering healthcare and biomedical applications.

This raises an important architectural question:

Is medical AI safety mainly a problem of better prompts, guardrails, workflows, and human review?

These are important. But they are not enough.

In this article, I want to distinguish two related but fundamentally different ideas:

Harness engineering
Steerable biomedical world models

Harness engineering controls an AI system from the outside.

A steerable biomedical world model structures biomedical reasoning from the inside.

The difference matters because medical AI is not only a text-generation problem. It is ultimately about representing biological states, modeling interventions, reasoning about possible state transitions, and inspecting failures when expected changes do not occur.

That requires more than external guardrails.

It requires a state-action-transition-feedback architecture.

1. What is harness engineering?

In modern AI engineering, we rarely expose a raw model directly to users.

Instead, we wrap it with layers of control:

prompt templates
system prompts
RAG pipelines
tool calling
function calling
workflow orchestration
output validators
safety filters
rule engines
human-in-the-loop review
audit logs
sandbox execution
permission control

This broad pattern can be described as harness engineering.

A typical harnessed AI system may look like this:


User Input

↓

Input Filter / Intent Classifier

↓

Prompt Template / System Prompt

↓

LLM / Agent

↓

Tool Calling / RAG / External APIs

↓

Output Validator

↓

Safety Filter

↓

Human Review, if needed

↓

Final Output

In software engineering, this is extremely useful.

For example, a code generation system may be wrapped with:


LLM Code Generator

↓

Static Analysis

↓

Unit Tests

↓

Type Checker

↓

Sandbox Execution

↓

Human Review

↓

Merge / Deploy

The core idea is simple:

We do not assume the model is perfectly reliable. Instead, we build external systems that make its behavior more controlled, inspectable, and reversible.

This approach is essential for deploying AI systems safely.

But in healthcare, it is not sufficient.

2. Medical AI absolutely needs harness engineering

Medical AI has higher risk than many other AI domains.

A poorly constrained medical AI system may:

mislead patients
fabricate medical references
overstep into diagnosis
suggest unsafe treatments
ignore contraindications
confuse health education with medical advice
overinterpret lab results
exaggerate efficacy
miss emergency red flags
delay proper care

So a medical AI system needs strong external controls.

For example:


Medical Knowledge Base

- RAG Retrieval
- Safety Rules
- Output Validation
- High-Risk Intent Detection
- Clinical Review
- Disclaimer Layer
- Audit Logging
- Permission Control

A basic medical AI workflow may look like:


User Question

↓

Risk Classification

↓

Medical Knowledge Retrieval

↓

LLM Response Generation

↓

Medical Safety Validation

↓

Diagnosis / Prescription / Emergency Risk Check

↓

Human Escalation, if needed

↓

Final Response

This kind of harness engineering is necessary.

But it mainly addresses AI behavior risk:


Is the AI hallucinating?

Is it overstepping?

Is it fabricating citations?

Is it giving unsafe advice?

Is it violating the product boundary?

These are important questions.

But they are not the whole problem.

Medical AI also faces a deeper problem:


Is the underlying biomedical reasoning valid?

That is where harness engineering is not enough.

3. Harnessed medical AI is not the same as a medical world model

Many medical AI agent systems look sophisticated:


LLM

- Medical Knowledge Base
- RAG
- Tool Calling
- Multi-Agent Workflow
- Report Generation
- Safety Filtering
- Clinician Review

Such systems can be useful.

They can help summarize records, review literature, explain medical terminology, generate reports, retrieve guidelines, and support administrative workflows.

But they are not necessarily medical world models.

Why?

Because they may not explicitly answer the following questions:


1. What is the current biological state?
2. How is an intervention represented as an action?
3. Given the current state and action, how might the state change?
4. How do alternative actions compare counterfactually?
5. If the expected change does not occur, where did the reasoning fail?

In short:


Workflow ≠ world model

RAG ≠ state representation

Agent ≠ transition model

Guardrail ≠ steerability

A medical world model is not just about making AI outputs safer.

It is about making biological state transitions more representable, inspectable, testable, and correctable.

4. What is a steerable biomedical world model?

A generic world model can be expressed as:


current state + action → predicted or hypothesized next state

Or:


S(t), A → S(t + Δt)

Where:

S(t) is the current state
A is an action
S(t + Δt) is the future state after that action

In robotics, this might mean:


robot position + motor command → next robot position

In a game environment, it might mean:


current frame + player action → next frame

In medicine, a more careful expression is:


current molecular / functional state

- intervention

→ testable hypothesis about biological state transition

This distinction is important.

In early biomedical systems, the “next state” should usually be interpreted as a testable transition hypothesis, not as a validated clinical outcome prediction.

A steerable biomedical world model should not be framed as:


This model can predict which treatment will work.

A more scientifically cautious framing is:


Given a current biological state, a candidate action, and mechanistic constraints, the model generates an auditable and testable hypothesis about the direction of state change.

In other words, early biomedical world models are better understood as:


state-action-transition hypothesis systems

not as:


validated clinical decision systems

This is the central idea behind the steerability framework I proposed in the preprint World Models for Biomedicine: A Steerability Framework.

The framework argues that biomedical world models should not merely forecast likely trajectories. They should support steerability through state representation, capability quantification, intervention-response semantics, counterfactual transition, and quality-control feedback.

Here, “steerability” does not mean that an AI model automatically controls the human body or replaces clinical judgment.

It means that the model makes state, action, transition hypotheses, mechanism evidence, uncertainty, and feedback inspection explicit enough for humans to examine, challenge, and revise.

5. Harness engineering vs steerable world modeling

The key difference can be summarized as:


Harness engineering controls the AI system from outside.

Steerable world modeling structures biomedical reasoning from inside.

Here is a more detailed comparison:

Dimension	Harness Engineering	Steerable Biomedical World Model
Core question	How do we make AI outputs safer?	How do we represent and inspect biological state transitions?
Main object	Model behavior, tools, workflows, outputs	Biological state, intervention action, transition hypothesis, feedback
Common components	Prompt, RAG, validator, guardrail, workflow	State, action, transition, counterfactual, QC
Risk addressed	AI behavior risk	Biomedical reasoning risk
Failure diagnosis	Did the model violate rules? Did a tool fail?	Was the state wrong? Was the action semantics wrong? Was the transition assumption wrong?
Engineering layer	External safety layer	Internal world-model layer
Sufficient for medical world modeling?	No	One core requirement
Typical goal	Safer output	More inspectable biomedical reasoning

Or more simply:


Harness Engineering:

LLM → safer output

Steerable World Model:

biological state → action → transition hypothesis → feedback

These are not competing approaches.

Medical AI needs both.

But they operate at different layers.

6. The core architecture: state-action-transition-feedback

A medical AI system that approaches world-model behavior should include more than:


LLM + RAG + guardrails

It should include at least the following components:


State Representation

Action Representation

Transition Estimation

Counterfactual Reasoning

Mechanism Evidence Chain

Quality-Control Feedback

A high-level architecture may look like this:


Patient Data

↓

State Representation

S(t)

↓

Candidate Action Representation

A

↓

Transition Hypothesis Estimation

Ŝ(t + Δt | A)

↓

Mechanism Evidence Chain

↓

Uncertainty / Confidence

↓

Quality-Control Feedback

↓

Next Iteration

Let’s unpack the main components.

6.1 State representation

The first question is:


What is the current biological state?

In medicine, this state should not be reduced to:


Disease = diabetes

Disease = depression

Disease = rheumatoid arthritis

A disease label is a phenotype-level description.

It is not yet a world-model state space.

A richer state representation may include:

DNA methylation state
transcriptomic state
proteomic state
metabolomic state
immune state
inflammatory state
organ function
pathway activity
network module state
aging-related module state
individual longitudinal trajectory

For example:


S(t) = [

immune_module_state,

mitochondrial_module_state,

metabolic_module_state,

inflammation_resolution_state,

organ_function_state,

...

]

This representation could be a vector, graph, hierarchy, or multimodal embedding.

The form may vary.

The key requirement is:

The model must define what biological state it is trying to simulate.

In the Capomics / mIC-vector framework described in my preprint, an individual can be represented as a combination of module-level intrinsic capability states, rather than as a single biological age or risk score.

6.2 Action representation

In medicine, an action is not merely a label.


drug A

exercise

nutrition intervention

sleep improvement

behavioral therapy

These are surface names.

A world model needs to represent an action in terms of biological semantics:


A = {

target_modules,

mechanism,

direction,

dose,

timing,

duration,

sequence,

context,

uncertainty

}

For example, the same “exercise intervention” may have different biological meanings in different individuals:


Individual 1: improves insulin sensitivity

Individual 2: increases inflammatory burden

Individual 3: improves mitochondrial adaptation

Individual 4: causes recovery failure due to overtraining

Therefore, medical actions must enter an intervention-response semantics layer.

They cannot remain simple database labels.

6.3 Transition estimation

The core question of a world model is:


Given current state S(t) and action A, how might the state change?

Formally:


S(t), A → Ŝ(t + Δt | A)

But in medicine, this must be handled carefully.

An early system should not claim:


The model predicts this treatment will work.

A more rigorous expression is:


The model proposes a mechanistically constrained and auditable hypothesis about the direction of state transition.

This can be described as:


knowledge-constrained transition tendency

Meaning:

Based on available biological mechanisms, network structure, individual state, and intervention semantics, the model estimates a possible direction of state change, which still requires experimental, longitudinal, or clinical validation.

This is one of the main boundaries between ordinary medical question-answering and medical world modeling.

A medical QA system asks:


What does the literature say?

A medical world model asks:


If the current state is like this, and this action is applied, which direction might the biological state move?

Can this transition hypothesis be tested?

If it fails, where might the failure occur?

6.4 Counterfactual reasoning

Medical decision-making is naturally counterfactual.

We often want to ask:


What if we do A instead of B?

What if we sequence A before B?

What if we do nothing?

What if the same intervention is applied to different baseline states?

This cannot be solved by retrieval alone.

A world model should be able to represent:


Ŝ(t + Δt | A)

Ŝ(t + Δt | B)

Ŝ(t + Δt | no intervention)

Then compare those possible trajectories.

At the current stage, such comparisons should be understood as comparisons between counterfactual transition hypotheses, not as validated individualized clinical outcome predictions.

That distinction is critical.

6.5 Quality-control feedback

A medical world model should not only generate hypotheses.

It should also help inspect failure.

If an expected transition does not occur, the system should ask:


1. Was the state measured incorrectly?
2. Was the action defined incorrectly?
3. Did the expected module response fail to occur?
4. Did the state fail to move in the expected direction?
5. Did downstream phenotype propagation fail?
6. Was the time window inappropriate?
7. Was the dose or sequence inappropriate?
8. Was the individual baseline different from assumed?

This can be represented as:


Expected Transition

↓

Observed Transition

↓

Deviation Detected

↓

Failure Localization

↓

Model Revision / Hypothesis Revision

This is where steerability becomes important.

A conventional model may only report:


prediction error

A steerable biomedical world model should help localize the failure:


failure occurred at state measurement

failure occurred at action semantics

failure occurred at transition assumption

failure occurred at downstream propagation

In the preprint, I describe this as a shift from a “what-if simulator” toward a “why-not steering system.”

The model should not only ask:


What if we do this?

It should also ask:


Why did the expected transition not happen?

7. Example: drug ranking vs steerable state transition

Suppose a patient shows inflammation-related abnormalities.

A basic biomedical knowledge system may output:


This drug is related to inflammatory pathways.

A harnessed medical AI system may output:


This drug is related to inflammatory pathways, but this is not medical advice. Please consult a physician.

That response is safer.

But it is still not a world model.

A steerable biomedical world model should ask further:


1. What is the current inflammatory module state?
2. Are the patient-specific abnormalities located in the pathway affected by this drug?
3. What are the drug action’s targets, direction, and module-response semantics?
4. Is the action hypothesized to move the state toward a desired biological direction?
5. Is the predicted shift molecular, functional, or phenotypic?
6. If the intervention fails, where might the failure occur?

A comparison:

System type	Output behavior	World-model capability?
Medical knowledge base	Provides related knowledge	No
RAG medical QA	Retrieves and summarizes	No
Guardrailed medical agent	Produces safer answers	Not sufficient
Drug ranking system	Produces candidate rankings	Not sufficient
Steerable biomedical world model	Builds a state-action-transition-feedback evidence chain	Begins to approach world modeling

I use “begins to approach” intentionally.

A true medical world model also requires data quality, longitudinal validation, intervention datasets, uncertainty calibration, safety boundaries, task-specific evaluation, and clinical assessment.

8. What should SteeraMed point toward?

If SteeraMed is understood as a research, method, or platform direction for steerable medical AI, then it should not be limited to:


Medical LLM + RAG + safety guardrails

That is useful, but it is mainly an application-layer medical AI system.

The deeper question is:


How can medical AI become steerable rather than merely constrained?

In other words:


How can medical AI move from external control toward structured biomedical reasoning?

Architecturally, SteeraMed could be designed as two layers:


SteeraMed Architecture

1. Harness Layer
    - permission control
    - safety boundaries
    - compliance rules
    - output validation
    - human review
    - audit logging
2. Steerability Layer
    - state representation
    - action semantics
    - counterfactual transition
    - mechanism evidence chain
    - quality-control feedback

The first layer asks:


Can the AI speak safely?

The second layer asks:


Can the biomedical state be represented, simulated, inspected, and corrected?

Both are necessary.

9. A layered architecture for serious medical AI

A serious medical AI system may require at least five layers:


┌──────────────────────────────────┐

│ Human Oversight Layer             │

│ Clinicians, researchers, users     │

└──────────────────────────────────┘

↑

┌──────────────────────────────────┐

│ Clinical Governance Layer         │

│ Scope, responsibility, regulation  │

└──────────────────────────────────┘

↑

┌──────────────────────────────────┐

│ Harness Engineering Layer         │

│ Prompt / RAG / Guardrail / Audit  │

└──────────────────────────────────┘

↑

┌──────────────────────────────────┐

│ Steerable World Model Layer       │

│ State / Action / Transition / QC  │

└──────────────────────────────────┘

↑

┌──────────────────────────────────┐

│ Biomedical Data Layer             │

│ Omics / EHR / Wearables / Imaging │

└──────────────────────────────────┘

Each layer addresses a different problem:

Layer	Problem addressed
Biomedical Data Layer	Where the data come from
Steerable World Model Layer	How biological state and transition are modeled
Harness Engineering Layer	How AI behavior is constrained and validated
Clinical Governance Layer	Whether the system is appropriate for a real context
Human Oversight Layer	How humans interpret and decide

This helps avoid a common mistake:

External guardrails cannot replace an internal biomedical world model.

And a world-model concept cannot replace governance, validation, and safety deployment.

10. A checklist for medical AI builders

If you are building a medical AI system, here is a simple checklist.

Harness engineering checklist


[ ] Is there a system prompt?

[ ] Are medical safety boundaries defined?

[ ] Is high-risk intent detected?

[ ] Are diagnosis and prescription boundaries enforced?

[ ] Are RAG sources traceable?

[ ] Is output validation implemented?

[ ] Is human review available?

[ ] Are audit logs retained?

[ ] Is uncertainty expressed?

[ ] Is there a medical disclaimer?

Steerable world model checklist


[ ] Is the patient state space defined?

[ ] Can the system distinguish disease labels from biological states?

[ ] Can interventions be represented as actions?

[ ] Are intervention-response semantics defined?

[ ] Can transition direction be estimated?

[ ] Can counterfactual paths be compared?

[ ] Can mechanism evidence chains be generated?

[ ] Can uncertainty be represented?

[ ] Can failures be localized?

[ ] Can feedback revise the next hypothesis?

If a system only satisfies the first checklist, it is a harnessed medical AI system.

If it also begins to satisfy the second checklist, it starts moving toward a medical world model.

11. Scientific boundary and risk clarification

A steerable biomedical world model is not a clinical automation system.

It should not be interpreted as:


AI can replace physicians.

AI can automatically recommend treatment.

AI can predict individual treatment efficacy.

AI can be directly used for clinical decisions.

A more accurate framing is:


A research architecture for generating, organizing, and testing biomedical state-transition hypotheses.

Any clinical use would require:

prospective validation
clinical studies
safety evaluation
real-world follow-up
physician oversight
regulatory review
clearly defined scope
responsibility boundaries

At the current stage, steerability is best understood as:


research framework

engineering architecture

mechanism-reasoning system

hypothesis-generation system

not as a validated clinical product capability.

Disclaimer:

This article is for research and technical discussion only. It does not provide medical advice, diagnosis, or treatment recommendations. Any biomedical world model intended for clinical use would require prospective validation, safety evaluation, regulatory review where applicable, and clinical oversight.

12. Conclusion

Harness engineering and steerable biomedical world modeling are both important.

But they solve different problems.

Harness engineering asks:


How do we make AI systems safer, more controllable, and more compliant?

Steerable biomedical world modeling asks:


How do we make medical states, interventions, and state transitions representable, inspectable, testable, and correctable?

In one sentence:


Harness engineering makes medical AI safer to use.

Steerable world modeling makes biomedical reasoning more inspectable.

The future of medical AI should not be only:


larger models

- more medical literature
- more complex agent workflows

It also needs:


explicit state representation

- explicit action semantics
- testable transition hypotheses
- auditable mechanism chains
- diagnosable feedback loops

The first truly useful medical world models may not be the ones that claim to predict every treatment outcome.

They may be more modest, more auditable, and more falsifiable systems:

They do not claim to know the future.

They make every assumption about state, action, transition, mechanism, and uncertainty explicit enough to be tested.

That may be the key step from predictive medical AI toward steerable medical AI.

References

Xiong J. World Models for Biomedicine: A Steerability Framework. Preprints.org, 2026.

DOI: https://doi.org/10.20944/preprints202605.0366.v1
SEWO / Steerable Medicine World Model:

https://steerable.world
SteeraMed concept site:

https://steeramed.com
SteeraMed concept site:

https://steeramed.org
DeepOMe / DeepOMe Biology and Longevity AI:

https://deepome.com

Weak World Models vs Strong World Models in Biomedicine

JXIONG — Fri, 15 May 2026 14:43:24 +0000

Why early medical world models should start as auditable transition priors, not black-box drug-response engines.

Most medical AI systems today are built to answer prediction questions:

Is this patient high risk?
Is this image abnormal?
Is this biomarker outside the reference range?

A biomedical world model asks a different kind of question:

Given a current biological state and a candidate action, what direction might the system move next?

That shift sounds small, but it changes the architecture completely.

Instead of building a black-box model that jumps directly from patient data to treatment recommendations, early biomedical world models should probably begin as weak world models: auditable, prior-constrained systems that estimate plausible transition tendencies and generate testable hypotheses.

Here, weak does not mean scientifically weak. It means the model does not yet learn a full transition function from large-scale intervention trajectories.

Strong biomedical world models may come later. But they will require longitudinal state–action–next-state data that medicine rarely has at scale today.

What is a world model?

In AI and reinforcement learning, a world model is a system that represents how an environment works.

At a high level, it usually needs four things:

State — what the system looks like now
Action — what intervention is being applied
Transition — how the state may change after the action
Objective — what direction is considered better or worse

In a game, the state might be the current screen, the action might be moving left or right, and the transition model predicts what happens next.

In medicine, the environment is much harder.

The “state” is not just a diagnosis code. It may include molecular networks, methylation signals, protein interactions, immune activity, metabolism, medication history, tissue context, and longitudinal changes over time.

The “action” is also not simple. It could be a drug, a supplement, a lifestyle intervention, a diet change, a behavioral program, or a combination of these.

The “transition” is the hardest part: estimating how a living system may move after an intervention.

In early biomedical systems, this “predicted next state” should usually be interpreted as a transition hypothesis, not as a validated clinical forecast.

That distinction matters.

Why medicine cannot jump directly to strong world models

A strong biomedical world model would learn something like this:

current biological state + intervention → future biological state

For example:

patient molecular state at time t + compound A → predicted molecular state at time t + Δt

This is the kind of model people often imagine when they hear “AI for personalized medicine.”

But building it well requires data that is difficult to obtain:

molecular measurements before intervention
clear records of the intervention
dose, timing, adherence, and exposure information
molecular measurements after intervention
enough repeated examples across different people
outcome feedback
safety signals
controls for confounders
longitudinal follow-up

In other words, a strong biomedical world model needs state–action–next-state data.

Most medical datasets are not organized this way.

They are often cross-sectional, incomplete, noisy, population-averaged, and weakly connected to actual intervention outcomes.

So if we pretend we already have a fully learned drug-response world model, we risk overclaiming.

A safer starting point is a weak world model.

What is a weak biomedical world model?

A weak biomedical world model does not claim to predict clinical outcomes directly.

Instead, it represents the current biological state, encodes candidate actions, and estimates whether an action has a plausible direction of effect based on biological priors, mechanistic constraints, and auditable evidence.

A simple version looks like this:

current state + candidate action + biological knowledge → transition tendency

The key phrase is transition tendency.

A weak model does not say:

This intervention will work for this patient.

It says something closer to:

Based on the modeled molecular state and known biological mechanisms, this action is hypothesized to move the system toward a matched reference state or predefined desired biological direction, subject to validation.

That output should be treated as a hypothesis, not a clinical recommendation.

This distinction matters because a predicted molecular direction is not the same as clinical benefit. A molecular shift becomes useful only when it is linked to mechanism engagement, safety, phenotype, and downstream outcome validation.

A weak world model can still be useful if it is auditable, conservative, and designed to produce testable next steps.

Weak world model vs strong world model

Here is the difference in engineering terms:

Dimension	Weak biomedical world model	Strong biomedical world model
Primary role	Generate plausible hypotheses	Predict future biological states
Core data	Current state, prior knowledge, mechanisms, networks	Longitudinal state–action–next-state data
Transition model	Knowledge-constrained transition tendency	Empirically learned transition function
Output	Auditable direction-of-effect hypothesis	Predicted next state or outcome distribution
Best use	Prioritization, experimental design, validation planning	Adaptive intervention planning under validated constraints
Main risk	Overinterpreting hypotheses as medical instructions	Learning spurious, unsafe, or non-generalizable transitions

The weak version is not “worse” in a simple sense.

It is a different stage of maturity.

In domains where direct intervention-response data is scarce, a weak world model may be the responsible first architecture.

A biomedical example: state, action, transition

Imagine a system that uses molecular data to represent a patient-specific disease, aging, or biological stress state.

The model may represent the current state as a perturbation vector over biological networks:

S(t) = current molecular network perturbation state

A candidate intervention can be represented as an action:

A = compound, drug, supplement, or behavioral intervention

The model then estimates a possible transition tendency:

Ŝ(t + Δt | A) = hypothesized next-state direction under action A

The important question is not only whether the action touches the abnormal network.

The better question is:

Does the action plausibly move the modeled system toward a matched reference state or a predefined desired biological direction?

That gives us a more useful abstraction:

current state → candidate action → hypothesized direction of biological movement

This is the core of steerability.

Why direction may matter more than risk

Most medical prediction models estimate risk.

Risk is useful, but it is not the same as control.

A risk model might say:

This person is more likely to develop condition X.

A world-model-style system asks:

What actions might change the trajectory of the system?

That is a different computational problem.

It requires the model to represent not just correlation, but possible intervention paths.

In software terms, this is the difference between a read-only dashboard and a simulation environment.

A dashboard tells you what is happening.

A world model helps you ask what might happen if you do something.

But in medicine, the answer should be framed carefully:

not “this will work,”
but “this is a testable transition hypothesis.”

Why auditability is not optional in medical AI

In consumer AI, a black-box answer may be annoying.

In medicine, it can be dangerous.

A biomedical world model should not only output a ranked list of candidate actions. It should expose the reasoning path behind the ranking.

An auditable state–action–transition evidence chain might include:

Current molecular state

What abnormalities, perturbations, or biological contexts are being represented?
Candidate action representation

What biological targets, pathways, directions, or mechanisms are associated with the action?
Counterfactual transition tendency

Does the action plausibly move the modeled state toward or away from a matched reference state or desired biological direction?
Mechanism annotation

What prior biological evidence supports this direction, and where is it uncertain?
Uncertainty and confidence

Where is the evidence strong, weak, missing, biased, or contradictory?

This is especially important for early-stage systems.

If the model is weak, the audit trail is not a nice-to-have feature. It is the main safety layer.

This is the core idea behind steerability: the model should not simply output a prediction, but expose a path that can be inspected, challenged, and corrected.

Where SEWO fits

SEWO is one implementation-oriented example of this direction.

It can be viewed as an early research framework for steerable biomedical world modeling: a system designed to make state representation, candidate actions, transition hypotheses, mechanisms, and uncertainty inspectable.

In this framing, SEWO is not a fully validated treatment simulator.

It is closer to an auditable hypothesis-generation scaffold:

patient molecular state
→ candidate action representation
→ counterfactual transition tendency
→ mechanism annotation
→ uncertainty / confidence

The current SEWO-style approach should be understood as a knowledge-constrained transition prior, not an empirically learned drug-response transition model.

That means it can help generate hypotheses about what to test next. It should not be interpreted as proof that a specific intervention will produce clinical benefit.

A weak model should be honest about what it is not

A weak biomedical world model is not:

a clinical prescription engine
a validated drug-response predictor
a substitute for clinical trials
a diagnostic authority
a guarantee that a candidate intervention will work
a replacement for professional medical judgment

It is better described as:

a hypothesis generator
a transition prior
a mechanism-aware prioritization system
an evidence-chain builder
a way to organize state, action, and possible direction of change

This language may sound cautious, but that caution is useful.

It prevents the system from pretending to have evidence it does not yet have.

How weak models can become stronger

A weak biomedical world model can become stronger when it starts receiving longitudinal feedback.

The missing data structure is:

state before intervention → action → state after intervention

For example:

molecular profile before compound A
→ compound A exposure, dose, timing, and context
→ molecular profile after compound A

With enough high-quality examples, the system can begin learning more realistic transition functions.

That creates a data flywheel:

measure individual biological state
generate an auditable intervention hypothesis
apply or test the intervention in an appropriate research or clinical setting
measure the post-intervention state
compare predicted and observed transitions
link molecular shifts to mechanism engagement, safety, phenotype, and outcomes
update the model

This is where the long-term promise of biomedical world models becomes interesting.

But the first step is not pretending that the flywheel already exists.

The first step is designing the model so that the flywheel can exist later.

Why this matters for N-of-1 medicine

Population averages are useful, but many medical and longevity questions are individual.

An N-of-1 question sounds like this:

Given this person's current biological state, what intervention is most plausible to test next, and what should we measure afterward?

That question cannot be answered well by risk prediction alone.

It requires:

an individual state representation
a candidate action representation
a transition hypothesis
a measurable target
a safety boundary
a feedback loop

This is why world models are a natural fit for personalized and root-cause-oriented medicine.

But again, the safest path is staged development.

Start with weak, auditable transition priors.

Then use longitudinal evidence to move toward stronger models.

The main takeaway

Biomedical world models should not begin as black-box drug-response engines.

That is too strong a claim for the data most systems have today.

A more responsible starting point is the weak world model:

an auditable state–action–transition framework that uses molecular state, candidate intervention knowledge, biological mechanisms, and uncertainty estimates to generate testable hypotheses about possible biological movement.

Strong world models may eventually learn real transition functions from longitudinal intervention data.

But weak world models are still valuable now because they give medical AI a better structure:

not just prediction,
but state → action → transition → mechanism → uncertainty → feedback

The first useful biomedical world models may not be the ones that claim to know the future.

They may be the ones that make every assumption about state, action, transition, mechanism, and uncertainty explicit enough to be tested.

References

Xiong J. World Models for Biomedicine: A Steerability Framework. Preprints.org. 2026. DOI: 10.20944/preprints202605.0366.v1. Available at: https://www.preprints.org/manuscript/202605.0366/v1.
SEWO — Steerable Medicine World Model. Available at: https://steerable.world.
DeepOMe. Available at: https://deepome.com.

Disclaimer

This article is for research and technical discussion only. The framework described here is not a medical device, not a clinical decision system, and not a substitute for professional medical advice.

Any biomedical world model intended for clinical use would require prospective validation, safety evaluation, regulatory review where applicable, and clinical oversight.

Can an Algorithm Find What Your Body Actually Needs? Introducing SEMO for Longevity Technology

JXIONG — Mon, 11 May 2026 02:51:50 +0000

Everyone in longevity technology is asking a familiar question:

What should I take?

A supplement?

A metabolite?

A senolytic candidate?

A lifestyle intervention?

A drug-repurposing lead?

But maybe that is not the best first question.

A better one might be:

Where, inside my biological network, is there a measurable mismatch that an intervention could plausibly reshape?

That is the problem the SEMO algorithm is designed to address.

SEMO is not just another recommendation engine. It is a network-medicine algorithmic framework developed by DeepoMe to connect individual omics signals, compound target networks, and personalized intervention hypotheses.

The algorithm was introduced by Jianghui Xiong in a bioRxiv preprint titled “Utilizing Pre-trained Network Medicine Models for Generating Biomarkers, Targets, Re-purposing Drugs, and Personalized Therapeutic Regimes: COVID-19 Applications.” In that paper, SEMO stands for Selective Remodeling of Protein Networks by Chemicals.

The SEMO framework has also moved beyond a conceptual proposal. A related Chinese invention patent, “Method, system and application for generating compound intervention schemes based on a pre-trained model”, has been granted under publication number CN117766054B.

In the broader vision of steerable biomedical AI, SEMO can be understood as one possible algorithmic layer beneath a larger question raised by Steerable World:

Can we move from predicting biological decline to steering biological state?

The Longevity Problem: Too Many Signals, Too Little Direction

Longevity science has no shortage of measurements.

We can measure:

DNA methylation age
inflammatory markers
metabolic biomarkers
microbiome composition
gene variants
wearable signals
proteomic and metabolomic profiles
sleep, glucose, HRV, and exercise response

The problem is no longer simply “not enough data.”

The problem is that most data do not automatically tell us what to do next.

A biological age clock may say that someone is aging faster than expected.

A blood test may show a few abnormal markers.

A wearable may show poor recovery.

A supplement database may list hundreds of potentially beneficial compounds.

But how do we connect these pieces into an individualized intervention hypothesis?

Most current systems still rely heavily on population-level logic:

people with marker X often benefit from nutrient Y
compound A has been associated with pathway B
supplement C is popular for aging-related mechanism D
risk score E is high, so generic intervention F is recommended

This can be useful, but it is not enough for true precision longevity.

Longevity is not a one-marker problem.

It is a network-state problem.

From Deficiency Thinking to Network Gap Thinking

Traditional health recommendations often begin with a deficiency model:

What nutrient is low?

SEMO points toward a different model:

What network region shows a compound-relevant state gap in this individual?

This distinction matters.

A person may not be “deficient” in a simple nutritional sense. Yet their biological network may still show a local mismatch: a compound's known target region may differ from its surrounding molecular background in a way that is visible through omics data.

That difference can be treated as a network gap.

In simple terms, SEMO asks:

Which proteins or genes are targeted by a compound?
Where do those targets sit inside the human protein–protein interaction network?
What is the individual’s omics state around those targets?
Is the target region different from the nearby non-target background?
Could that difference suggest a personalized intervention hypothesis?

This is a very different logic from “this supplement is good for everyone.”

It is closer to:

This compound maps to a network region that appears unusually relevant to this person’s current biological state.

What SEMO Does Algorithmically

At a high level, SEMO combines several ideas from network medicine and representation learning.

It can be described as a pre-trained network-medicine framework that:

maps compounds to known or predicted biological targets
embeds those targets into protein–protein interaction networks
constructs reusable compound–network representations
compares target-associated regions with local network backgrounds
integrates individual omics signals, such as DNA methylation-derived features
generates ranked hypotheses for biomarkers, targets, drug repurposing, or personalized intervention candidates

The key idea is that a compound should not be treated only as a chemical name.

A compound is also a network perturbation hypothesis.

It may influence a set of targets.

Those targets sit inside biological modules.

Those modules may correspond to aging-related functions such as inflammation, metabolism, mitochondrial adaptation, immune regulation, stress response, repair, or cellular resilience.

When an individual’s omics data are mapped onto these same network structures, the algorithm can ask whether a compound-relevant region appears meaningfully different from the local background.

That is where SEMO becomes interesting for longevity.

From Preprint to Patent: SEMO Has Already Been Demonstrated

The original SEMO paper did not present the algorithm only as a theoretical idea. It used COVID-19 as a demonstration case.

In the preprint, Xiong described SEMO as a pre-trained network medicine model that divides the global human protein–protein interaction network into smaller sub-networks, then quantifies the potential effects of chemicals by statistically comparing target and non-target gene sets.

The study combined 9,607 PPI gene sets with 2,658 chemicals to create a pre-trained pool of SEMO features. These features were then applied to DNA methylation profiling data from two clinical COVID-19 cohorts to identify SEMO patterns associated with COVID-19 severity.

One important result was that nutraceutical-derived SEMO features could be used to predict COVID-19 severity, with reported AUC values of approximately 81% in the training data and 80% in independent validation data.

That COVID-19 demo matters because it shows SEMO’s intended use case: not simply describing compounds, but linking compound-associated network effects with individual molecular states and clinically relevant outcomes.

The later Chinese invention patent further signals that SEMO-related methods have been formalized as an applied technical system for generating compound intervention schemes from pre-trained models. For longevity technology, this is important because it suggests that SEMO can be viewed not only as a research algorithm, but also as an IP-backed computational infrastructure for personalized intervention hypothesis generation.

Why This Matters for Longevity Technology

Longevity interventions are difficult because aging is not one disease and not one pathway.

Aging involves many interacting processes:

mitochondrial decline
chronic inflammation
immune remodeling
epigenetic drift
stem-cell exhaustion
proteostasis stress
metabolic inflexibility
cellular senescence
impaired stress adaptation
reduced repair capacity

If we treat aging as a list of hallmarks, we still face a practical problem:

Which hallmark matters most for this person, now?

SEMO offers a possible computational route.

Instead of asking whether a compound is generally anti-aging, SEMO can help ask whether a compound’s network region is specifically relevant to an individual’s current molecular state.

That turns longevity intervention from a generic recommendation problem into a structured hypothesis-generation problem.

For example:

A compound associated with mitochondrial targets may not be equally relevant to every older adult.
A polyphenol with inflammatory and metabolic targets may matter more in one network state than another.
A repurposed drug may appear promising only when its target region aligns with an individual's molecular mismatch.
A lifestyle or nutritional intervention may need to be evaluated by the network response it induces, not by its label.

This is the real promise: not “the best supplement,” but the best next hypothesis for this biological network state.

SEMO as a Bridge Between Network Medicine and Steerable AI

The SEWO framework introduced at Steerable World argues that biomedical AI should become steerable, not merely predictive.

A steerable biomedical model should be able to represent state, simulate intervention-induced transitions, inspect failure, and revise the next hypothesis.

SEMO can be viewed as a more concrete algorithmic component inside this broader vision.

If SEWO asks:

How do we steer biological trajectories?

SEMO asks:

Which compound-linked network regions may be worth steering first?

This makes SEMO complementary to a steerable medicine world model.

A world model needs:

a state representation
candidate interventions
intervention-response semantics
counterfactual transition logic
feedback and quality control

SEMO contributes to the candidate-intervention layer by converting compound information and individual omics data into ranked, network-aware hypotheses.

In other words, SEMO helps transform a massive intervention search space into a smaller, more biologically interpretable set of possibilities.

From Recommendation Lists to Personal Science

Many precision-health products still generate static recommendation lists.

You take a test.

You receive a report.

The report suggests supplements, foods, lifestyle changes, or risk categories.

But longevity technology should not stop there.

A more powerful model is longitudinal personal science:

Measure an individual’s biological state.
Identify network gaps or state mismatches.
Generate intervention hypotheses.
Apply a safe, clinically appropriate intervention.
Re-measure the state.
Ask whether the expected network gap changed.
Keep, revise, or discard the hypothesis.

SEMO is valuable because it fits into this iterative loop.

It does not have to claim that an intervention will definitely work.

Instead, it can generate a testable network hypothesis:

This compound-related network region appears relevant. If the hypothesis is correct, a suitable intervention should move the corresponding molecular state in a measurable direction.

That is a much more scientific formulation than a one-time recommendation.

It also aligns with the future of N-of-1 longevity studies, where the goal is not to prove that one intervention works for everyone, but to understand which intervention changes which state in which individual.

Why Network Gaps Are Better Than Generic Rankings

A generic ranking might say:

compound A is popular
compound B has strong literature support
compound C affects many aging pathways
compound D has antioxidant activity

A SEMO-style ranking asks something more specific:

does compound A map to this person’s relevant network region?
does the target region show a measurable omics difference?
is the signal local, interpretable, and potentially trackable?
can we re-measure the same network region after intervention?

This is important because longevity science is full of interventions that look promising in general but fail to translate consistently across individuals.

The reason may not be that the intervention has no biological effect.

It may be that the intervention is applied to the wrong state.

SEMO provides a way to make state matching more explicit.

A Practical Example

Imagine two people with similar biological age scores.

Person A has a network pattern suggesting mitochondrial-adaptation stress.

Person B has a network pattern suggesting inflammation-resolution imbalance.

A generic longevity report might recommend similar “anti-aging” supplements to both.

A SEMO-style algorithm would instead ask:

Which compound target networks align with Person A’s mitochondrial-related mismatch?
Which compound target networks align with Person B’s inflammatory-resolution mismatch?
Are these differences visible in the individual omics layer?
Can future measurements test whether the predicted network state changed?

This is not clinical treatment advice.

It is a computational hypothesis-generation process.

But that is exactly what longevity technology needs at this stage: better hypotheses, better measurement loops, and better ways to connect interventions with individual biological states.

What SEMO Does Not Claim

It is important to be clear about the boundary.

SEMO is not a validated clinical decision system.

It does not prove that a compound is effective for a specific person.

It does not replace clinical trials, safety assessment, medical supervision, or regulatory evaluation.

It does not mean that network association equals therapeutic benefit.

Instead, SEMO should be understood as an algorithmic framework for organizing intervention hypotheses.

Its value is not that it gives a final answer.

Its value is that it makes the question more computable:

Given this individual’s molecular network state, which compound-linked network hypotheses deserve attention, testing, and longitudinal follow-up?

That is already a major step beyond generic supplement logic.

The Potential Contribution to Longevity Science

SEMO could contribute to longevity technology in at least five ways.

1. More individualized intervention hypotheses

It can help move from population-average recommendations to individual network-state matching.

2. Better prioritization of compounds

Instead of ranking compounds only by literature popularity or general mechanism, SEMO can prioritize candidates by their relationship to a person’s omics-mapped network state.

3. Mechanistic traceability

Because the algorithm uses target networks and omics features, hypotheses can be inspected and challenged rather than hidden inside a black box.

4. Longitudinal feedback

A network gap can potentially be re-measured after intervention, allowing the hypothesis to be updated.

5. Integration with steerable biomedical AI

SEMO can provide candidate intervention hypotheses for broader steerable world-model systems, such as the SEWO framework introduced at Steerable World.

Why DeepoMe’s Approach Is Worth Watching

DeepoMe has been developing computational approaches around DNA methylation, aging, capability measurement, and network-based intervention reasoning.

SEMO fits naturally into that direction.

If DNA methylation and other omics layers provide a way to observe durable biological state, and SEWO provides a framework for steerable biomedical world models, then SEMO helps answer a practical intermediate question:

Which compound-linked network interventions might be worth testing for this state?

That makes SEMO less like a conventional supplement recommender and more like a hypothesis engine for precision longevity.

Final Thought: The Future Is Not “What Should I Take?”

The future of longevity technology should not be reduced to the question:

What should I take?

A more mature question is:

What is my current biological network state, what mismatch is most actionable, which intervention could plausibly move it, and how will we know whether it worked?

SEMO is interesting because it tries to make that question computational.

It does not promise a shortcut to immortality.

It does not turn longevity into a one-click recommendation system.

It does not eliminate the need for validation.

But it may help build the algorithmic foundation for a more rigorous form of personalized longevity science:

network-aware
omics-informed
hypothesis-driven
longitudinally testable
compatible with steerable biomedical AI

That is the potential contribution of SEMO.

Not just recommending interventions.

Helping longevity technology learn where to steer next.

Suggested hashtags

#Longevity #Bioinformatics #BiomedicalAI #NetworkMedicine #PrecisionHealth #SEMO #SEWO #AI

Can You Steer It? Introducing SEWO — A Steerable Medicine World Model Framework

JXIONG — Fri, 08 May 2026 05:57:50 +0000

Everyone is building bigger AI models for biology. But here's a question nobody seems to be asking:

Can you steer it?

The Problem with Bigger Predictors

The field of AI for biomedicine is exploding. Virtual cell models, drug-response predictors, biological foundation models — billions of dollars are flowing into systems that aim to model cells, drugs, disease progression, and human biology.

But almost all of these systems share a critical limitation: they predict, but they cannot be steered.

A biomedical world model should not merely forecast what may happen next. It should allow a clinician or researcher to ask:

"What if we move in this direction instead?"

And then provide a reliable, auditable answer.

Introducing SEWO: Steerable Medicine World Model

DeepoMe Limited has released a new preprint: "World Models for Biomedicine: A Steerability Framework", introducing SEWO — a conceptual framework that proposes steerability as a foundational property for trustworthy biomedical AI.

📄 Preprint: https://doi.org/10.20944/preprints202605.0366.v1

SEWO is not another neural architecture. It's a meta-level framework — a specification layer that helps evaluate whether any biomedical world model (transformer, graph network, state-space model, or future architecture) is not only predictive, but also interpretable, constrained, counterfactual, and steerable.

The Rider and the Horse

Think of it this way. A rider doesn't micromanage every muscle of the horse. The rider provides directional signals through the reins. The horse maintains balance, adapts to terrain, and moves with its own embodied robustness.

Likewise, a steerable medicine world model should:

Accept directional guidance from human experts (add a therapeutic hypothesis, modify a nutritional condition, remove a confounding assumption)
Maintain internal consistency despite noise, missing data, and distribution shifts
Make its reasoning inspectable at every step

Five Structural Constraint Points

SEWO defines five constraint points that any biomedical world model should satisfy:

1. State Representation

Biological states should be decomposed into modular, interpretable components — specifically, modular Intrinsic Capability (mIC) vectors that break biological function into auditable units.

2. Capability Quantification

How far is a biological system from functional breakdown? SEWO introduces the Capomics Index: CI = 1 − PAI — a single metric to quantify system resilience.

3. Input–Response Semantics

Every perturbation (drug, nutrient, environmental factor) should map to computationally tractable inputs with explicit biological meaning — not just latent vectors.

4. Counterfactual Transition Modeling

A valid biomedical world model must simulate plausible "what-if" trajectories: What happens if we intervene here? What if we remove this assumption?

5. Five-Gate Quality Control Loop

Every reasoning chain follows: State → Input → Response → ΔmIC → Phenotype

Each gate can be independently inspected, challenged, and falsified. No black boxes.

Why This Matters for AI Engineers

If you're building AI systems for biomedicine, SEWO offers a practical checklist:

[ ] Can your model's state representation be decomposed into interpretable modules?
[ ] Can you quantify how close a system is to failure?
[ ] Do inputs map to biologically meaningful perturbations?
[ ] Can you simulate counterfactual intervention scenarios?
[ ] Can each step of your model's reasoning be independently audited?

If the answer is no to any of these, you may have a powerful predictor — but not a steerable world model.

Steering, Not Predicting

A flavonoid doesn't simply "kill" a cancer cell. It influences a signaling network, alters protein–protein interactions, shifts regulatory dynamics — and the cell's own machinery responds.

SEWO extends this logic to AI: instead of asking AI to dictate outcomes from above, we should build systems that accept biologically meaningful directional input, recompute coherent trajectories, and make their reasoning transparent.

Steering, not predicting.

Get Involved

The SEWO project is open for community discussion:

🌐 Project home: steerable.world
📄 Preprint: doi.org/10.20944/preprints202605.0366.v1
📧 Contact: info@deepome.com

Important note: This manuscript is a preprint and has not yet undergone peer review. The framework is a research proposal and conceptual specification, not a clinically validated system.

Hashtags: #SEWO #SteerableWorldModel #BiomedicalAI #WorldModels #TrustworthyAI #MachineLearning #AI