AI in Global Health and Equity

Global health AI should be evaluated as part of a public health program or service, not as a model transferred between countries. A system that performs well in one setting can fail when the population, data, language, workflow, infrastructure, referral capacity, governance, or maintenance environment differs. The practical question is whether the complete workflow improves a defined public health decision under the conditions where it will operate.

Learning Objectives

This chapter equips readers to:

  • Define the intended decision, current workflow, affected population, and accountable institution before selecting a technology
  • Assess connectivity, electricity, computing, data, interoperability, workforce, and institutional constraints at the intended sites
  • Distinguish model performance from local validity, service impact, equity, and sustainability
  • Compare an AI system with the current workflow, simpler digital tools, and non-AI alternatives
  • Evaluate whether data governance, benefit sharing, capacity building, and exit terms preserve meaningful local authority
  • Assign ownership for validation, procurement, maintenance, monitoring, incident response, fallback, and suspension

Core rule: Evaluate the whole service under local operating conditions. A model is useful only when the required inputs are available, its outputs remain valid, people can act on those outputs, and the service can be governed and maintained.

Decision sequence:

  1. Define the need. Name the decision, current workflow, intended users, affected population, available action, and non-AI baseline.
  2. Measure the setting. Document site-level connectivity, power, hardware, data, language, staffing, referral, financing, policy, and maintenance constraints.
  3. Test transferability. Review evidence from relevant populations and settings, then require local validation and workflow testing proportionate to risk.
  4. Compare complete options. Assess benefits, harms, acceptability, feasibility, resource use, and equity across the AI proposal and viable alternatives.
  5. Assign authority and lifecycle duties. Establish who controls data and deployment, who benefits, who maintains and monitors the system, and who can suspend or end its use.

Critical takeaways:

  • Country income group is not a deployment specification. Conditions vary within countries, districts, facilities, and communities.
  • The World Health Organization states that digital interventions are not substitutes for functioning health systems.
  • External benchmark performance does not establish local effectiveness, fairness, or service impact.
  • A simpler system can be the stronger option when it is more reliable, maintainable, affordable, and compatible with the current workflow.
  • Local institutions and affected communities need meaningful authority over data, implementation, monitoring, benefits, and exit conditions.

Introduction: Evaluate the Service, Not Only the Model

Evidence for an algorithm and evidence for a public health intervention are not interchangeable. Performance measured in one population, device environment, language, or workflow does not establish that the same system will improve decisions elsewhere. Evaluation must include the people, infrastructure, information systems, operating procedures, downstream services, and governance needed to convert an output into action.

WHO’s guideline on digital interventions for health system strengthening recommends examining benefits, harms, acceptability, feasibility, resource use, and equity. Its AI ethics and governance guidance identifies principles covering autonomy; well-being, safety, and the public interest; transparency; accountability; inclusiveness and equity; and responsiveness and sustainability. Together, these sources support a health-system assessment rather than technology transfer based on model accuracy alone.

Constraints differ within as well as between countries. A national connectivity estimate does not show whether a particular facility has reliable power, affordable data, compatible records, trained staff, referral capacity, or authority to maintain a system. Site-level measurement and local participation are therefore prerequisites for an implementation decision.

Detailed methods follow in Context-Appropriate AI Design, Algorithmic Fairness Across Populations, and Data Governance in Global Health; practice questions are in Check Your Understanding.

The Digital Divide in Global Health AI

The digital divide is not a single connectivity measure. It includes the infrastructure, information systems, workforce, financing, governance, and service capacity required to use an AI output safely and consistently. Weakness in one layer can make the complete workflow unavailable even when the model itself runs.

Interdependent Infrastructure Constraints

1. Connectivity Divide

Connectivity should be assessed at the point of service, including uptime, bandwidth, latency, cost, device access, and the ability to continue safely during an outage.

Key findings: In 2025, ITU estimated that 2.2 billion people remained offline. Internet use was 85% in urban areas versus 58% in rural areas, and 77% among men versus 71% among women (ITU, 2025).

2. Computing Infrastructure Divide

Most AI models assume access to:

  • Cloud computing (AWS, Azure, GCP) - requires internet + payment infrastructure
  • GPUs for training ($5,000–$50,000 per unit) - prohibitive for many institutions
  • Continuous electricity - The World Bank reported in 2026 that 655 million people lacked electricity access (World Bank, 2026)

Example: Training a medical imaging model

High-income setting:

# Standard GPU training approach
import tensorflow as tf

# Assumes: V100 GPU ($10,000), 24/7 electricity, high-speed internet
model = tf.keras.applications.ResNet50(weights='imagenet', include_top=False)

# Train on 100,000 chest X-rays
history = model.fit(
 train_dataset, # Loaded from cloud storage
 epochs=100,
 batch_size=32, # Requires 16GB+ GPU memory
 validation_data=val_dataset
)

Illustrative constraints in a low-resource facility:

  • No GPU available → Training time: 100 hours (GPU) → 2,000+ hours (CPU)
  • Intermittent electricity → Training interrupted, progress lost
  • Limited internet → Cannot download large pre-trained models or datasets
  • Cost: purchasing and powering GPU hardware competes with the facility’s operating budget

3. Data Infrastructure Divide

# Illustrative values only (not measured data): comparison of health data infrastructure
import pandas as pd
import plotly.express as px

data_infrastructure = {
 'Feature': [
  'Electronic Health Records',
  'Health Information Exchange',
  'Unique Patient Identifiers',
  'Structured Data',
  'Interoperability Standards',
  'Data Quality Monitoring',
  'Real-time Surveillance Systems'
 ],
 'High-Income (%)': [95, 80, 90, 75, 70, 85, 90],
 'Upper-Middle (%)': [45, 25, 40, 35, 30, 35, 50],
 'Lower-Middle (%)': [15, 8, 15, 12, 10, 15, 25],
 'Low-Income (%)': [5, 2, 5, 5, 3, 5, 10]
}

df = pd.DataFrame(data_infrastructure)

# Visualize infrastructure gap
fig = px.bar(df, x='Feature',
    y=['High-Income (%)', 'Upper-Middle (%)',
    'Lower-Middle (%)', 'Low-Income (%)'],
    title='Health Data Infrastructure by Country Income Level',
    barmode='group',
    height=500)

fig.update_layout(xaxis_tickangle=-45)
fig.show()

Implications for AI:

  • No EHRs → No training data for predictive models
  • Paper records → Labor-intensive data entry, high error rates
  • No patient identifiers → Cannot track patients across visits
  • Unstructured data → Requires complex NLP preprocessing
  • No interoperability → Data silos prevent full analysis
  • Weak surveillance infrastructure → Event-based surveillance systems (HealthMap, WHO EIOS) detected only 9.2% of influenza outbreaks within a two-week window in a 24-country evaluation, with LMIC performance consistently weaker (Ganser et al., 2022). See AI in Disease Surveillance for details.

4. Human Capacity Divide

Trained data scientists and health workers are concentrated in high-income countries, and many low-income countries fall below WHO’s minimum health workforce density benchmark. Tools that assume spare analyst or clinician time may have no one to run them.

The Paradox of Need

Settings with the greatest potential AI impact often have the least capacity to develop, deploy, and maintain AI systems. This creates a vicious cycle where:

  1. Limited resources → Limited AI capacity
  2. Limited AI capacity → Dependence on external solutions
  3. External solutions → Not context-appropriate
  4. Poor outcomes → Distrust of technology
  5. Distrust → Reduced investment → Back to #1

Breaking this cycle requires intentional capacity building and locally led innovation.

However, user sentiment data complicates the assumption that distrust is uniform. Anthropic’s report on 80,508 interviews with Claude.ai users across 159 countries found that respondents in Sub-Saharan Africa (18%), Central Asia (17%), and South Asia (17%) were the most likely to say they had no concerns about AI, roughly double the share in North America (8%), Oceania (8%), and Western Europe (9%) (Anthropic, 2026). The report places personal transformation highest in East Asia (19%) and associates life management with Western developed countries. Interviewees in the first group reported fewer concerns, so the distrust in step 4 of the cycle above (poor outcomes leading to distrust) may be less entrenched than assumed. The interviews sampled existing Claude.ai users, not whole populations, report no significance tests, and did not test tools designed for local context.

The capacity cycle is not the only mismatch the 2026 literature now measures. Stürenburg et al. used Llama-3.1-70B to classify 3.7 million OECD CRS project descriptions (USD ~332 billion, 157 countries, 2000–2022) into 17 GBD disease categories and compared per-capita ODA rank with DALY rank: NCDs were 59.5% of global DALYs but 2.5% of disease-specific aid, while HIV/AIDS and STIs were 6% of burden and 34% of aid (manual-label accuracy 0.91 on 2,060 projects) (Stürenburg et al., 2026). The authors treat DALY alignment as a heuristic, not an allocation rule, and the pipeline is text classification of donor disbursements, not a financing dashboard, not domestic or household spending, and not a care endpoint.

A multi-country randomized trial of GPT-4o assistance on standardized clinical vignettes (N=249 physicians in Indonesia, Kenya, and the Netherlands) found larger absolute performance gains in Kenya (+18 percentage points) than in Indonesia (+10.7 percentage points) or the Netherlands (+7.2 percentage points), with a reduction in the Kenya–Netherlands performance gap under GPT-4o assistance (Rounding et al., 2026). This is vignette performance under controlled conditions: the control arm lacked traditional resources such as internet and guidelines, harms were not assessed, and the result is not patient-outcome or population-health endpoint evidence.

The larger gain in Kenya suggests that LLM assistance effects may depend on setting; it is not evidence of reduced mortality or safer care (Rounding et al., 2026).


Context-Appropriate AI Design

Principles for Resource-Limited Settings

Effective AI in low- and middle-income countries (LMICs) is designed for constraints: intermittent connectivity, unreliable power, imperfect data, and local language and practice.

1. Offline-First Design

Challenge: Internet connectivity is unreliable or absent in many settings.

Solution: Design AI systems that work offline, syncing when connectivity is available.

import sqlite3
import json
from datetime import datetime

class OfflineAISystem:
 """
 Offline-first AI diagnostic system with sync capability

 Designed for: Rural health clinics with intermittent connectivity
 """

 def __init__(self, local_db_path='local_diagnostics.db'):
  self.local_db = sqlite3.connect(local_db_path)
  self.setup_local_database()
  self.model = self.load_lightweight_model()

 def setup_local_database(self):
  """Create local SQLite database for offline operation"""
  cursor = self.local_db.cursor()
  cursor.execute('''
   CREATE TABLE IF NOT EXISTS diagnostics (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    patient_id TEXT,
    image_path TEXT,
    prediction TEXT,
    confidence REAL,
    timestamp TEXT,
    synced INTEGER DEFAULT 0
   )
  ''')
  self.local_db.commit()

 def load_lightweight_model(self):
  """Load compressed model for resource-limited devices"""
  import tensorflow as tf

  # Load quantized TFLite model (int8 weights are about 4x smaller than float32)
  interpreter = tf.lite.Interpreter(
   model_path="malaria_detector_quantized.tflite"
  )
  interpreter.allocate_tensors()
  return interpreter

 def diagnose(self, patient_id: str, image_path: str):
  """
  Run diagnosis entirely offline

  No internet required - model runs on device
  """
  # Preprocess image
  image = self.preprocess_image(image_path)

  # Run inference locally
  input_details = self.model.get_input_details()
  output_details = self.model.get_output_details()

  self.model.set_tensor(input_details[0]['index'], image)
  self.model.invoke()

  prediction = self.model.get_tensor(output_details[0]['index'])[0]

  # Store result locally
  result = {
   'patient_id': patient_id,
   'image_path': image_path,
   'prediction': 'Positive' if prediction[0] > 0.5 else 'Negative',
   'confidence': float(prediction[0]),
   'timestamp': datetime.now().isoformat()
  }

  self.save_local(result)
  return result

 def save_local(self, result):
  """Save result to local database"""
  cursor = self.local_db.cursor()
  cursor.execute('''
   INSERT INTO diagnostics
   (patient_id, image_path, prediction, confidence, timestamp, synced)
   VALUES (?, ?, ?, ?, ?, 0)
  ''', (
   result['patient_id'],
   result['image_path'],
   result['prediction'],
   result['confidence'],
   result['timestamp']
  ))
  self.local_db.commit()

 def sync_when_online(self, api_endpoint: str):
  """
  Sync local results to central server when connectivity available

  Designed to handle intermittent connectivity gracefully
  """
  import requests
  from requests.exceptions import ConnectionError, Timeout

  cursor = self.local_db.cursor()
  cursor.execute('SELECT * FROM diagnostics WHERE synced = 0')
  unsynced_records = cursor.fetchall()

  synced_count = 0
  for record in unsynced_records:
   try:
    # Attempt to sync with timeout
    response = requests.post(
     api_endpoint,
     json={
      'patient_id': record[1],
      'prediction': record[3],
      'confidence': record[4],
      'timestamp': record[5]
     },
     timeout=5 # Fail fast if connection is slow
    )

    if response.status_code == 200:
     # Mark as synced
     cursor.execute(
      'UPDATE diagnostics SET synced = 1 WHERE id = ?',
      (record[0],)
     )
     self.local_db.commit()
     synced_count += 1

   except (ConnectionError, Timeout):
    # Connection failed - continue to next record
    # Will retry on next sync attempt
    continue

  return synced_count

# Usage in rural clinic
system = OfflineAISystem()

# Works without internet
result = system.diagnose(
 patient_id='P12345',
 image_path='/images/blood_smear_001.jpg'
)

print(f"Diagnosis: {result['prediction']} (confidence: {result['confidence']:.2%})")

# Later, when internet available (even briefly)
try:
 synced = system.sync_when_online('https://api.health.gov/diagnostics')
 print(f"Synced {synced} records to central database")
except:
 print("Sync failed - will retry later")

Key design principles:

  • Local inference: The model runs on the device, with no internet needed
  • Local storage: A SQLite database stores results
  • Opportunistic sync: Records sync when connectivity is available
  • Fail gracefully: The system keeps working if sync fails
  • Lightweight models: Quantized TFLite models (int8 weights take about one quarter of the storage of float32 weights)

2. Low-Power Design

Challenge: Unreliable electricity, battery-powered devices.

Solution: Optimize for minimal power consumption.

import tensorflow as tf
import numpy as np

class LowPowerOptimizer:
 """
 Optimize AI models for low-power operation

 Target: Run on battery-powered tablets or phones in field settings
 """

 @staticmethod
 def quantize_model(model_path: str, output_path: str):
  """
  Int8 quantization can reduce model size and improve inference efficiency.
  Measure accuracy, latency, memory, and power on the target hardware.
  """
  converter = tf.lite.TFLiteConverter.from_saved_model(model_path)
  converter.optimizations = [tf.lite.Optimize.DEFAULT]
  converter.target_spec.supported_types = [tf.int8]

  tflite_quant_model = converter.convert()

  with open(output_path, 'wb') as f:
   f.write(tflite_quant_model)

  return output_path

 @staticmethod
 def prune_model(model, target_sparsity=0.5):
  """
  Remove 50% of weights with minimal impact on accuracy

  Result: 50% less computation, 40-60% less power
  """
  import tensorflow_model_optimization as tfmot

  # Define pruning schedule
  pruning_schedule = tfmot.sparsity.keras.PolynomialDecay(
   initial_sparsity=0.0,
   final_sparsity=target_sparsity,
   begin_step=0,
   end_step=1000
  )

  # Apply pruning
  pruned_model = tfmot.sparsity.keras.prune_low_magnitude(
   model,
   pruning_schedule=pruning_schedule
  )

  return pruned_model

 @staticmethod
 def batch_inference(images: list, model, batch_size=1):
  """
  Batch size trades memory against per-call overhead

  Small batches limit memory; larger batches amortize overhead
  """
  results = []

  # Process in small batches to minimize memory
  for i in range(0, len(images), batch_size):
   batch = images[i:i+batch_size]
   batch_array = np.array(batch)

   # Single inference call for batch
   predictions = model.predict(batch_array)
   results.extend(predictions)

  return results

 @staticmethod
 def estimate_battery_life(
  model_size_mb: float,
  inferences_per_day: int,
  battery_capacity_mah: int = 10000
 ):
  """
  Estimate battery life for field device

  Args:
   model_size_mb: Model size in MB
   inferences_per_day: Expected daily usage
   battery_capacity_mah: Device battery capacity

  Returns:
   Estimated days of operation
  """
  # Power estimates (rough)
  idle_power_mw = 100 # Screen off, background processes
  inference_power_mw = 1000 + (model_size_mb * 2) # ~2mW per MB model size
  inference_time_sec = 0.1 + (model_size_mb * 0.01) # ~10ms per MB

  # Daily power consumption
  inference_energy_mwh = (
   inference_power_mw * inference_time_sec / 3600 * inferences_per_day
  )
  idle_energy_mwh = idle_power_mw * 24 # 24 hours

  total_daily_mwh = inference_energy_mwh + idle_energy_mwh

  # Battery capacity in mWh (assuming 3.7V nominal)
  battery_mwh = battery_capacity_mah * 3.7

  # Days of operation
  days = battery_mwh / total_daily_mwh

  return days

# Compare model options
original_model_size = 100 # MB
quantized_model_size = 25 # MB

original_battery = LowPowerOptimizer.estimate_battery_life(
 original_model_size,
 inferences_per_day=50,
 battery_capacity_mah=10000
)

quantized_battery = LowPowerOptimizer.estimate_battery_life(
 quantized_model_size,
 inferences_per_day=50,
 battery_capacity_mah=10000
)

print(f"Original model: {original_battery:.1f} days battery life")
print(f"Quantized model: {quantized_battery:.1f} days battery life")
print(f"Improvement: {quantized_battery - original_battery:.1f} additional days")

Output example:

Original model: 15.3 days battery life
Quantized model: 15.4 days battery life
Improvement: 0.1 additional days

In this illustrative estimate, idle draw dominates daily energy use, so a fourfold smaller model adds little battery life.

Design implications:

  • Quantization can reduce memory and energy use, but battery effects must be measured on the target device and workload
  • Model size matters: Smaller models generally use less energy per inference
  • Batch processing when possible to amortize overhead
  • Sleep modes between uses to conserve power
Additional Edge AI Techniques

Beyond quantization and pruning, two additional techniques enable AI deployment in resource-limited settings:

Knowledge distillation: Train a smaller “student” model to mimic a larger “teacher” model’s predictions. Performance retention depends on the teacher, student, task, data, and evaluation. Measure it on the intended target hardware and population.

Federated learning: Train models across distributed devices without centralizing sensitive data. Each device trains locally and shares only model weight updates (not raw data) with a central server. Critical for privacy-preserving collaboration across health facilities that cannot share patient data. A 2024 systematic review found federated models can achieve similar accuracy to centralized models while providing stronger privacy protections. A 2026 Nature Medicine review extends this logic to infectious disease surveillance and modeling: federated approaches can let outbreak data remain local while analyses run across distributed datasets, but adoption remains limited and depends on governance, standards, and local analytic capacity (Khurana et al., 2026).

These techniques matter for public health because cloud-dependent AI excludes settings with unreliable connectivity. Edge AI runs entirely on local devices, enabling real-time diagnostics without internet access.

3. Robust to Low-Quality Data

Challenge: Data in LMICs often has:

  • Poor image quality (low-resolution cameras, poor lighting)
  • Missing values (incomplete records)
  • Inconsistent formats (lack of standardization)
  • Limited labeled data (no specialist time for labeling)

Solution: Design models that are robust to data quality issues.

import tensorflow as tf
import numpy as np

class RobustDataHandler:
 """
 Handle common data quality issues in LMIC settings
 """

 @staticmethod
 def augment_for_poor_quality(image):
  """
  Augmentation strategy for low-quality images

  Train model on artificially degraded images so it handles
  poor quality gracefully in deployment
  """
  augmentations = tf.keras.Sequential([
   # Simulate poor lighting
   tf.keras.layers.RandomBrightness(0.3),
   tf.keras.layers.RandomContrast(0.3),

   # Simulate low resolution
   tf.keras.layers.Resizing(64, 64), # Downsample
   tf.keras.layers.Resizing(224, 224), # Upsample back

   # Simulate blur (camera shake, focus issues)
   tf.keras.layers.GaussianNoise(0.1),

   # Simulate color variations (different cameras)
   tf.keras.layers.Lambda(
    lambda x: tf.image.random_hue(x, 0.1)
   ),
  ])

  return augmentations(image)

 @staticmethod
 def handle_missing_features(df, strategy='median'):
  """
  Robust handling of missing clinical data

  Common in settings with:
  - Incomplete laboratory testing (cost constraints)
  - Paper records (transcription errors)
  - Limited diagnostic capacity
  """
  import pandas as pd
  from sklearn.impute import SimpleImputer

  if strategy == 'median':
   imputer = SimpleImputer(strategy='median')
  elif strategy == 'indicator':
   # Create missingness indicators - may be informative
   # (e.g., missing lab test → test not available at facility)
   imputer = SimpleImputer(strategy='median', add_indicator=True)

  imputed = imputer.fit_transform(df)

  return imputed

 @staticmethod
 def few_shot_learning_setup(base_model, n_examples=10):
  """
  Learn from very few labeled examples

  Scenario: Specialist can only label 10-50 examples
  Solution: Transfer learning + few-shot learning
  """
  # Freeze base model (pre-trained on large dataset)
  base_model.trainable = False

  # Add small trainable head
  model = tf.keras.Sequential([
   base_model,
   tf.keras.layers.GlobalAveragePooling2D(),
   tf.keras.layers.Dense(128, activation='relu'),
   tf.keras.layers.Dropout(0.5), # High dropout for small data
   tf.keras.layers.Dense(1, activation='sigmoid')
  ])

  # Use aggressive regularization for small data
  model.compile(
   optimizer=tf.keras.optimizers.Adam(learning_rate=0.0001),
   loss='binary_crossentropy',
   metrics=['accuracy']
  )

  return model

 @staticmethod
 def semi_supervised_learning(labeled_data, unlabeled_data, model):
  """
  Use abundant unlabeled data

  Scenario:
  - 100 labeled examples (specialist time is scarce)
  - 10,000 unlabeled examples (easy to collect)

  Solution: Pseudo-labeling / self-training
  """
  # Train initial model on labeled data
  X_labeled, y_labeled = labeled_data
  model.fit(X_labeled, y_labeled, epochs=50, verbose=0)

  # Predict on unlabeled data
  X_unlabeled = unlabeled_data
  pseudo_labels = model.predict(X_unlabeled)

  # Keep high-confidence predictions as pseudo-labels
  confidence_threshold = 0.9
  high_conf_mask = np.max(pseudo_labels, axis=1) > confidence_threshold

  X_pseudo = X_unlabeled[high_conf_mask]
  y_pseudo = (pseudo_labels[high_conf_mask] > 0.5).astype(int)

  # Retrain on labeled + pseudo-labeled data
  X_combined = np.vstack([X_labeled, X_pseudo])
  y_combined = np.hstack([y_labeled, y_pseudo])

  model.fit(X_combined, y_combined, epochs=50, verbose=0)

  return model

# Example: Train robust model for malaria detection
# with limited, poor-quality data

# Simulate limited labeled data
n_labeled = 50
X_train_small = X_train[:n_labeled]
y_train_small = y_train[:n_labeled]

# Load pre-trained base model
base_model = tf.keras.applications.MobileNetV2(
 input_shape=(224, 224, 3),
 include_top=False,
 weights='imagenet'
)

# Setup for few-shot learning
handler = RobustDataHandler()
model = handler.few_shot_learning_setup(base_model)

# Add augmentation for robustness to poor quality
train_dataset = tf.data.Dataset.from_tensor_slices(
 (X_train_small, y_train_small)
).map(
 lambda x, y: (handler.augment_for_poor_quality(x), y)
).batch(8)

# Train with limited data
model.fit(train_dataset, epochs=50)

# Optionally: Use semi-supervised learning with unlabeled data
X_unlabeled = X_train[n_labeled:] # Remaining data without labels
model = handler.semi_supervised_learning(
 labeled_data=(X_train_small, y_train_small),
 unlabeled_data=X_unlabeled,
 model=model
)

Key strategies:

  • Augmentation simulates poor quality during training
  • Imputation handles missing clinical data
  • Few-shot learning works with 10–100 labeled examples
  • Semi-supervised learning uses unlabeled data
  • Transfer learning from models trained on larger datasets

4. Culturally and Linguistically Appropriate

Challenge: Most AI health systems are designed in English for Western contexts.

Solution: Localize for language, culture, and local health practices.

class LocalizedHealthAI:
 """
 AI system adapted for local language and cultural context
 """

 def __init__(self, language='en', region='global'):
  self.language = language
  self.region = region
  self.load_local_resources()

 def load_local_resources(self):
  """Load language-specific and region-specific resources"""
  # Load local language model
  if self.language != 'en':
   # Use multilingual model or local language model
   self.language_model = self.load_multilingual_model()

  # Load local disease terminology
  self.local_terms = self.load_disease_terminology(self.region)

  # Load culturally appropriate guidance
  self.cultural_guidance = self.load_cultural_guidelines(self.region)

 def load_multilingual_model(self):
  """
  Load model that supports local languages

  Options:
  - mBERT: 104 languages
  - XLM-RoBERTa: 100 languages
  - AfriBERTa: African languages
  - IndicBERT: Indian languages
  """
  from transformers import AutoModelForSequenceClassification, AutoTokenizer

  # Example: Multilingual clinical text classifier
  model_name = "xlm-roberta-base"
  tokenizer = AutoTokenizer.from_pretrained(model_name)
  model = AutoModelForSequenceClassification.from_pretrained(model_name)

  return {'tokenizer': tokenizer, 'model': model}

 def load_disease_terminology(self, region):
  """
  Map local disease terms to standard terminology

  Example: Local names for diseases
  - "Malaria" → "Homa ya malaria" (Swahili; "homa" alone means fever), "Paludisme" (French), "Malária" (Portuguese)
  - "Tuberculosis" → "Kifua kikuu" (Swahili), "TB" (Global)
  """
  terminology_maps = {
   'east-africa': {
    'homa ya malaria': 'malaria',
    'kifua kikuu': 'tuberculosis',
    'kipindupindu': 'cholera',
    'ukimwi': 'hiv/aids'
   },
   'west-africa-french': {
    'paludisme': 'malaria',
    'tuberculose': 'tuberculosis',
    'choléra': 'cholera',
    'sida': 'hiv/aids'
   },
   'south-asia': {
    'malaria': 'malaria', # English widely used
    'tb': 'tuberculosis',
    'hiv': 'hiv/aids'
   }
  }

  return terminology_maps.get(region, {})

 def load_cultural_guidelines(self, region):
  """
  Culturally appropriate health guidance

  Example considerations:
  - Gender norms (who makes health decisions?)
  - Traditional medicine integration
  - Religious considerations
  - Dietary restrictions/norms
  """
  guidelines = {
   'global': {
    'gender_sensitivity': 'moderate',
    'traditional_medicine': 'acknowledge',
    'religious_considerations': 'respect',
   },
   'south-asia': {
    'gender_sensitivity': 'high', # May need male family member involvement
    'traditional_medicine': 'integrate', # Ayurveda widely practiced
    'religious_considerations': 'dietary_restrictions', # Vegetarian options
   },
   'middle-east': {
    'gender_sensitivity': 'high',
    'traditional_medicine': 'acknowledge',
    'religious_considerations': 'prayer_times', # Schedule around prayers
   }
  }

  return guidelines.get(region, guidelines['global'])

 def translate_symptoms(self, symptoms_text):
  """
  Translate symptom description to English for processing
  Then translate recommendations back to local language
  """
  if self.language == 'en':
   return symptoms_text

  # Use local language model or translation API
  # Example: Google Translate API, Azure Translator, or local model
  translated = self.translate_to_english(symptoms_text)
  return translated

 def generate_recommendation(self, diagnosis, confidence):
  """
  Generate culturally appropriate health recommendation
  """
  # Base recommendation
  recommendation = f"Diagnosis: {diagnosis} (confidence: {confidence:.0%})"

  # Add culturally appropriate guidance
  if self.cultural_guidance['traditional_medicine'] == 'integrate':
   recommendation += "\n\nThis recommendation can complement traditional treatments. Consult both your healthcare provider and traditional healer."

  if self.cultural_guidance['gender_sensitivity'] == 'high':
   recommendation += "\n\nPlease discuss this with your family before making treatment decisions."

  # Translate back to local language
  if self.language != 'en':
   recommendation = self.translate_from_english(
    recommendation,
    target_language=self.language
   )

  return recommendation

# Example: Deploy in rural Kenya (Swahili-speaking, East Africa)
system = LocalizedHealthAI(language='sw', region='east-africa')

# User reports symptoms in Swahili
symptoms_swahili = "Nina homa kali na kichwa kinaniuma"
# Translation: "I have severe fever and headache"

# System processes in local language
symptoms_english = system.translate_symptoms(symptoms_swahili)
diagnosis, confidence = system.diagnose(symptoms_english)

# Generate culturally appropriate recommendation in Swahili
recommendation = system.generate_recommendation(diagnosis, confidence)
print(recommendation)

Localization checklist:

  • Language: Support local languages, not just English
  • Terminology: Use local disease names and terms
  • Cultural norms: Respect gender roles, family decision-making
  • Traditional medicine: Acknowledge and integrate where appropriate
  • Religious considerations: Respect dietary restrictions, prayer times
  • Health literacy: Adjust communication complexity to education level

Successful Global Health AI Implementations

Case Study 1: Portable Eye Exam System (India)

Context: India carries a large burden of avoidable blindness, and diabetic retinopathy is a growing cause. India has too few ophthalmologists, concentrated in cities, to examine every person with diabetes for retinopathy.

Solution: AI-based diabetic retinopathy screening for rural primary care clinics. The algorithm’s performance on retinal photographs was evaluated by Gulshan et al., 2016, JAMA.

Key design decisions:

  • Offline operation: Works without internet
  • Low-cost hardware: Portable fundus cameras in place of conventional tabletop systems
  • Minimal training: Nurses or technicians operate the camera after brief training
  • Immediate results: Grading at the point of care
  • Automated referral: High-risk cases flagged automatically
class RetinopathyScreeningSystem:
 """
 Diabetic retinopathy screening for rural India

 Based on: Google's DR screening system deployed in Aravind Eye Hospitals
 """

 def __init__(self):
  self.model = self.load_model()
  self.sensitivity_threshold = 0.95 # High sensitivity to avoid missing cases

 def screen_patient(self, patient_id, fundus_image):
  """
  Screen for diabetic retinopathy

  Returns:
   - grade: None, Mild, Moderate, Severe, Proliferative
   - referral_urgency: Routine, Urgent, Emergency
   - confidence: Model confidence
  """
  # Preprocess image
  image = self.preprocess_fundus_image(fundus_image)

  # Predict DR grade
  prediction = self.model.predict(image)
  grade = self.interpret_prediction(prediction)

  # Determine referral urgency
  urgency = self.determine_urgency(grade, prediction)

  # Log result locally
  self.log_screening_result(patient_id, grade, urgency)

  return {
   'grade': grade,
   'referral_urgency': urgency,
   'confidence': float(prediction.max()),
   'recommendation': self.generate_recommendation(grade, urgency)
  }

 def determine_urgency(self, grade, prediction):
  """Determine referral urgency based on grade"""
  if grade in ['Severe', 'Proliferative']:
   return 'Emergency' # Refer within 1 week
  elif grade == 'Moderate':
   return 'Urgent' # Refer within 1 month
  elif grade == 'Mild':
   return 'Routine' # Refer within 3 months
  else:
   return 'None' # Rescreen in 1 year

 def generate_recommendation(self, grade, urgency):
  """Generate action plan in local language (Hindi/English)"""
  recommendations = {
   'Emergency': "तत्काल नेत्र विशेषज्ञ को दिखाएं (Urgent: See eye specialist immediately)",
   'Urgent': "एक महीने में नेत्र विशेषज्ञ से मिलें (See eye specialist within 1 month)",
   'Routine': "3 महीने में नेत्र विशेषज्ञ से मिलें (See eye specialist within 3 months)",
   'None': "एक साल बाद फिर से जांच करवाएं (Rescreen in 1 year)"
  }

  return recommendations.get(urgency, recommendations['None'])

# Populate these fields only from an evaluation of the exact deployed workflow
evaluation_fields = [
 'eligible_population',
 'images_graded',
 'ungradable_image_rate',
 'sensitivity_and_specificity_against_reference_standard',
 'referral_completion',
 'patient_outcomes',
 'resource_use'
]

Evidence boundary: The cited JAMA paper evaluated algorithm performance on retinal photographs; it did not establish the deployment counts, cost reduction, or blindness-prevention outcomes. Google has separately reported that its automated retinal-disease assessment system has screened more than 200,000 patients in clinics from the EU to rural India, a vendor-reported count rather than a clinical-outcome estimate (Google, 2023).

For a 2026 Nature Medicine Comment that frames the same program family’s expansion across India, Thailand, and Australia at more than a million screenings - still implementation lessons, not a mortality RCT - see Tiwari et al., 2026.

Key success factors:

  1. Designed for constraints: Offline operation and low-cost hardware
  2. Task-shifting: Nurses can operate the system, not only ophthalmologists
  3. Integration: Built into the existing primary care workflow
  4. Local partnership: Developed with Aravind Eye Hospitals (local expertise)
  5. Continuous improvement: Model updated based on local data

Case Study 2: Chest X-Ray AI (Sub-Saharan Africa)

Context: Tuberculosis remains a major cause of illness and death, and access to expert chest-radiograph interpretation is constrained in many settings.

Solution: AI system for TB screening from chest X-rays, intended for use with low-cost portable X-ray machines. The cited evaluation tested the CAD4TB software on chest radiographs (Murphy et al., 2020, Scientific Reports).

class TBScreeningSystem:
 """
 TB screening from chest X-rays in resource-limited settings

 Illustrative example; deployment countries are not established by the cited evaluation
 """

 def __init__(self, deployment_mode='offline'):
  self.model = self.load_quantized_model() # Lightweight for tablets
  self.deployment_mode = deployment_mode

 def screen_for_tb(self, xray_image, patient_demographics=None):
  """
  Screen chest X-ray for TB

  Args:
   xray_image: Chest X-ray (portable X-ray machine)
   patient_demographics: Age, HIV status (high-risk groups)

  Returns:
   - tb_likelihood: Probability of active TB
   - confidence: Model confidence
   - recommendation: Next steps
  """
  # Preprocess X-ray
  image = self.preprocess_xray(xray_image)

  # Predict TB likelihood
  tb_probability = self.model.predict(image)[0][0]

  # Adjust for high-risk populations (e.g., HIV+)
  if patient_demographics:
   tb_probability = self.adjust_for_risk_factors(
    tb_probability,
    patient_demographics
   )

  # Generate recommendation
  recommendation = self.generate_recommendation(tb_probability)

  return {
   'tb_likelihood': float(tb_probability),
   'confidence': self.calculate_confidence(tb_probability),
   'recommendation': recommendation
  }

 def adjust_for_risk_factors(self, base_probability, demographics):
  """
  Adjust probability for high-risk groups

  TB prevalence 20-30x higher in HIV+ populations
  """
  risk_multiplier = 1.0

  if demographics.get('hiv_positive'):
   risk_multiplier *= 1.5 # Increase concern threshold

  if demographics.get('age', 0) > 65:
   risk_multiplier *= 1.2 # Elderly at higher risk

  if demographics.get('previous_tb'):
   risk_multiplier *= 1.3 # Previous TB increases risk

  return min(base_probability * risk_multiplier, 0.99)

 def generate_recommendation(self, tb_probability):
  """Generate action plan"""
  if tb_probability > 0.7:
   return {
    'action': 'Immediate sputum test and clinical evaluation',
    'urgency': 'High',
    'explanation': 'High likelihood of active TB - requires confirmatory testing'
   }
  elif tb_probability > 0.4:
   return {
    'action': 'Sputum test recommended',
    'urgency': 'Moderate',
    'explanation': 'Possible TB - confirmatory testing needed'
   }
  else:
   return {
    'action': 'No immediate action, monitor symptoms',
    'urgency': 'Low',
    'explanation': 'Low likelihood of active TB'
   }

# Deployment hardware fields to verify before procurement
deployment_config = {
 'xray_device_and_version': None,
 'purchase_and_service_cost': None,
 'weight_and_transport_requirements': None,
 'power_and_battery_requirements': None,
 'compute_device': None,
 'model_version': None,
 'measured_inference_time': None
}

# Populate performance only from the exact version, threshold, population,
# reference standard, and workflow under evaluation.
performance = None

Evidence boundary: Murphy and colleagues evaluated CAD4TB version 6 on 5,565 chest radiographs and modeled that users of version 6 could process 132 subjects per day at an average $5.95 per screen, against 85 subjects per day at $8.38 for version 3 (Murphy et al., 2020). Those are modeled figures from one evaluation, not observed deployment counts or site counts in the countries named above.

Innovation: “AI + human” workflow

  • AI provides immediate preliminary reading
  • Flagged cases reviewed by radiologist remotely (via phone connectivity when available)
  • Measure radiologist workload, missed cases, confirmatory-testing demand, and time to treatment in the intended workflow

Case Study 3: Malaria Diagnosis (Southeast Asia)

Context: Microscopy is the gold standard for malaria diagnosis but requires a trained microscopist (scarce in rural areas). Rapid diagnostic tests (RDTs) are less accurate.

Solution: Smartphone-based microscopy with AI analysis (Yang et al., 2020, IEEE J Biomed Health Inform).

class SmartphoneMalariaDetection:
 """
 Malaria detection from smartphone microscopy images

 Hardware requirements depend on the validated imaging setup
 """

 def __init__(self):
  self.model = self.load_lightweight_model()
  self.quality_checker = self.load_quality_model()

 def analyze_blood_smear(self, smartphone_image):
  """
  Analyze blood smear image from smartphone microscope

  Challenges:
  - Variable image quality (lighting, focus)
  - Different smartphone cameras
  - User variation in slide preparation
  """
  # Step 1: Check image quality
  quality_score = self.quality_checker.predict(smartphone_image)

  if quality_score < 0.6:
   return {
    'status': 'poor_quality',
    'message': 'Please retake image with better focus/lighting',
    'guidance': self.image_quality_tips()
   }

  # Step 2: Detect parasites
  parasite_detected = self.model.predict(smartphone_image)
  parasite_count = self.count_parasites(smartphone_image)

  # Step 3: Calculate parasitemia (parasite density)
  parasitemia = self.calculate_parasitemia(parasite_count)

  # Step 4: Generate diagnosis
  diagnosis = self.generate_diagnosis(parasite_detected, parasitemia)

  return diagnosis

 def calculate_parasitemia(self, parasite_count, rbc_count=5000):
  """
  Calculate parasitemia as a percentage of counted red blood cells

  Illustrative severity bands (not a WHO classification;
  WHO severe-malaria criteria define hyperparasitemia as >10%):
  - <1%: Low
  - 1-5%: Moderate
  - >5%: Severe
  """
  parasitemia_percent = (parasite_count / rbc_count) * 100
  return parasitemia_percent

 def generate_diagnosis(self, parasite_detected, parasitemia):
  """Generate diagnosis and treatment recommendation"""
  if not parasite_detected:
   return {
    'diagnosis': 'Negative',
    'severity': None,
    'treatment': 'No antimalarial treatment needed',
    'follow_up': 'If symptoms persist, repeat test in 24 hours'
   }

  # Classify severity
  if parasitemia > 5:
   severity = 'Severe'
   treatment = 'URGENT: IV artesunate, hospitalization required'
  elif parasitemia > 1:
   severity = 'Moderate'
   treatment = 'Oral artemisinin-based combination therapy (ACT)'
  else:
   severity = 'Mild'
   treatment = 'Oral artemisinin-based combination therapy (ACT)'

  return {
   'diagnosis': 'Positive',
   'severity': severity,
   'parasitemia': f'{parasitemia:.2f}%',
   'treatment': treatment,
   'follow_up': 'Repeat test on day 3 to confirm parasite clearance'
  }

 def image_quality_tips(self):
  """Provide guidance for better image quality"""
  return """
  Tips for better images:
  1. Clean the smartphone camera lens
  2. Ensure good lighting (use phone flashlight if needed)
  3. Hold phone steady (use stand if available)
  4. Focus on thin area of blood smear
  5. Take multiple images from different areas
  """

# Hardware requirements to verify for the intended device and workflow
hardware = {
 'microscope_attachment_and_version': None,
 'validated_phone_and_camera': None,
 'purchase_and_service_cost': None,
 'weight': None,
 'power': None,
 'maintenance_and_quality_control': None
}

# Populate only from a field evaluation of the exact device and comparator
field_results = None

Evidence boundary: The cited paper supports an image-analysis method, not the four-country deployment, worker-training, testing-volume, speed, or cost outcomes. Populate these fields only from a field study of the exact device, workflow, and comparator.

Key innovation: Quality control

  • AI checks image quality before analysis
  • Provides real-time feedback to improve image capture
  • Reduces false results from poor-quality images

Case Study 4: SMS-Based Disease Surveillance (Uganda mTRAC)

Context: Uganda developed mTRAC to strengthen routine health-facility reporting and feedback using basic mobile phones.

Solution: mTRAC is an SMS-based reporting system integrated with DHIS2 and preset threshold alerts (UNICEF Uganda). It is enabling digital infrastructure, not evidence of an AI deployment.

How It Works:

  1. Weekly SMS Reports: Health workers send standardized SMS with disease counts
    • Example: DIAR 15 MAL 23 PNE 3 (Diarrhea 15 cases, Malaria 23, Pneumonia 3)
    • Works on basic feature phones (not smartphones)
    • No internet required (SMS via 2G network)
  2. Automated Data Processing:
    • Structured SMS formats capture case counts
    • Validates data (flags impossible values, missing reports)
    • Aggregates to district/national levels in real time
  3. Automated Outbreak Detection:
    • Compares current cases to historical baselines
    • Flags anomalies (statistical outliers)
    • Prioritizes alerts by severity and confidence
    • Sends alerts to district health teams within hours
  4. Feedback Loop:
    • Health workers receive confirmation SMS
    • District teams get weekly summary reports
    • System prompts non-reporters automatically

Deployment Scale: UNICEF reported 4,431 facilities, more than 62,000 registered health workers, and nearly 80% complete and on-time weekly reporting in the second quarter of 2016 (UNICEF Uganda).

Monitoring record:

# Use verified program records for the specified period and denominator
monitoring_fields = [
 'facilities_expected_to_report',
 'facilities_reporting_completely_and_on_time',
 'message_delivery_failures',
 'data_quality_exceptions',
 'alerts_generated_and_investigated',
 'time_from_alert_to_action',
 'program_and_facility_costs'
]

Why This Succeeded:

  1. Context-Appropriate Technology:
    • SMS works on basic phones (no smartphone needed)
    • Functions with 2G networks (reliable even in rural areas)
    • Minimal training required (standardized format)
    • Offline-capable (SMS queues when no signal)
  2. Simple, Sustainable:
    • Uses a standardized reporting format
    • Can be integrated with national information systems
    • Requires local operational ownership and support
    • Integrated with existing workflows (weekly reporting)
  3. Government Ownership:
    • Uganda Ministry of Health owns system
    • Hosted on government servers
    • Ugandan team provides support
    • Sustainable beyond donor funding
  4. Evidence of Impact:
    • UNICEF reports the program’s facility and health-worker reach and its 2016 reporting completeness and timeliness
    • The cited source does not establish causal effects on outbreak detection, costs, or health outcomes
    • Transfers to other countries or reporting domains require separate verification

Lessons for Other LMICs:

  • Start simple: SMS before apps, basic phones before smartphones
  • Build on existing: Weekly reporting was already routine; mTRAC digitized it
  • Government ownership: Sustainability requires local control and capacity
  • Demonstrate value: Document early operational results to build long-term support
  • Plan for scale: Designed for national deployment from the start, not as a series of pilot projects

Expansion Beyond Disease Surveillance:

  • Stock-out reporting (medicines, vaccines)
  • Birth and death registration
  • Maternal health monitoring
  • Community health worker supervision
  • Supply chain logistics

Key Innovation: The alerting component uses preset thresholds rather than a documented machine-learning model. Threshold alerts are:

  • Transparent (health teams understand how alerts are generated)
  • Maintainable (local IT teams can update thresholds)
  • Reliable (does not fail due to model drift or data shifts)
  • Trustworthy (health workers trust what they understand)
Why SMS-Based Surveillance Works

Advantages Over Smartphone Apps:

  • Broad device compatibility: Basic phones can support structured reporting without requiring smartphones
  • Lower hardware requirements: Existing feature phones may avoid a smartphone procurement requirement
  • Reliable: 2G SMS works where 3G/4G internet is unreliable
  • Familiar: Health workers already use SMS, so the learning curve is short
  • Battery efficient: Feature phones last days to weeks on a charge, against hours for smartphone apps
  • Maintainable: Simpler technology that local teams can support

When to Use SMS vs Apps:

  • SMS: Structured reporting, high coverage priority, limited infrastructure
  • Apps: Complex data, multimedia needed, high smartphone penetration

Choose the simplest technology that works reliably in the deployment setting.

Case Study 5: Open-Source NLP for Clinical Note Surveillance (Brazil)

Context: Brazil’s Unified Health System (SUS) generates millions of unstructured free-text clinical notes annually. Critical public health signals, including underreported conditions such as gender-based violence, remain buried in narrative text that traditional surveillance systems cannot process.

Solution: Vital Strategies’ Brazil team deployed open-source NLP to convert unstructured clinical notes into structured surveillance data within SUS (Vital Strategies, February 2026; WHO & IndiaAI, AI Health Casebook, 2026).

How It Works:

  1. NLP extraction: Open-source language models parse free-text clinical notes, identifying diagnoses, risk factors, and social determinants not captured in structured fields
  2. Structured output: Extracted data is mapped to standardized public health categories, enabling integration with existing surveillance pipelines
  3. Surveillance enrichment: Conditions typically underreported in structured data (notably gender-based violence) surface through narrative text analysis

Scale:

  • 39 million clinical notes processed in the pilot phase
  • Deployed within Brazil’s existing public health infrastructure (SUS)
  • Uses open-source models, reducing licensing costs and enabling local adaptation

Why This Matters for LMICs:

  • Resource-efficient: Open-source tools avoid vendor lock-in and recurring license fees
  • Builds on existing data: Does not require new data collection; it uses information already in clinical records
  • Addresses underreporting: Surfaces conditions that patients disclose in clinical encounters but that never reach surveillance systems through structured reporting
  • Reproducible: The open-source approach allows adaptation to other health systems with similar free-text documentation

This case study was featured in the WHO-supported Casebook on Real-World Impact of AI in Health, launched at the India AI Impact Summit in February 2026. The same event saw the release of Version 2.0 of Vital Strategies’ Foundations & Futures report, which assessed AI readiness across 63 countries and introduced an AI Use-Case Prerequisites Matrix distinguishing minimum conditions for safe initiation from the foundations required for sustained, population-level integration.

For a related discussion of NLP applied to surveillance data streams, see the Syndromic Surveillance section in the Surveillance chapter.


Interpreting Global Health AI Implementation Cases

Implementation cases should be read as connected claims, not as product catalogs. A diagnostic-accuracy paper can support a statement about performance for the evaluated model, threshold, population, and reference standard. It cannot by itself support a deployment count, cost per screening, workforce reduction, patient-outcome effect, or national scale-up claim. Those outcomes require separate operational or comparative evidence.

Before adapting a case, record the exact model and hardware version, site, period, eligible population, data exclusions, comparator, reference standard, workflow, and endpoint. Then map every reported number to the source that measured it. If a field is unknown, leave it unknown rather than borrowing a value from another implementation. This prevents a common error in global health writing: combining plausible details from several programs into one apparently documented success story.

The local decision should also test whether the downstream pathway exists. A screening system has limited value if confirmatory testing, referral, treatment, maintenance, or replacement parts are unavailable. An SMS reporting system can improve timeliness without being an AI system. A simple threshold may be preferable to machine learning when it is transparent, maintainable, and adequate for the response. Technology category should never substitute for evidence that the complete service pathway works.

For pilots, prespecify technical reliability, data completeness, subgroup performance, referral or response completion, staff workload, recurrent cost, and failure recovery. Preserve the preexisting workflow until the replacement is shown to be dependable. Scale only after the site can operate, monitor, and repair the system without relying on an informal external rescue pathway.

Practical Action Framework for Implementing AI in Resource-Limited Settings

Steps for public health practitioners considering AI implementation in low-resource contexts:

Phase 1: Assessment and Planning (1-3 months)

For a validated multi-country readiness framework, see Vital Strategies’ Foundations & Futures (Version 2.0, 2026), which evaluated AI readiness across 63 countries along five dimensions: governance, data systems, connectivity, human capacity, and sustainable financing (Vital Strategies, February 2026).

Step-by-Step Assessment Checklist

Infrastructure Assessment:

☐ Electricity reliability

  • % of target facilities with reliable power? _______
  • Alternative power available? (solar, batteries, generators)
  • If <80% reliable: Plan for battery-powered or low-power solutions

☐ Internet connectivity

  • Network type available? (2G / 3G / 4G / fiber / satellite)
  • Reliability? (always / intermittent / rare)
  • Cost per MB? _______ (high costs → offline-first design)
  • If intermittent: Plan for offline-capable systems + sync when connected

☐ Existing technology

  • % health workers with smartphones? _______
  • % with basic phones? _______
  • Existing digital systems? (EMR, reporting systems)
  • If <50% smartphones: Consider SMS/basic phone solutions

Capacity Assessment:

☐ Technical skills

  • IT staff available? Yes / No | Number: _______
  • Skills present: ☐ Programming ☐ Database ☐ System admin ☐ Data analysis
  • Training capacity: High / Medium / Low
  • Gap: What skills missing? _______________________

☐ Data quality

  • Current data completeness: _______%
  • Current data timeliness: _______ (days from collection to use)
  • Data validation processes: Yes / No
  • If <80% complete/accurate: Address data quality BEFORE AI implementation

☐ Workflow integration

  • Current reporting burden: _______ minutes/day per health worker
  • Existing workflows documented? Yes / No
  • Stakeholder buy-in? (Health workers / Managers / IT / Leadership): _______
  • Red flag: If AI adds >10 minutes/day, expect resistance

Financial Assessment:

☐ Budget planning

  • One-time costs: Hardware $_______ | Software $_______ | Training $_______
  • Recurring costs: Maintenance $_______ /year | Internet $_______ /month
  • Funding sources: ☐ Government ☐ Donors ☐ Partnership ☐ Other: _______
  • Sustainability: Funded beyond pilot period? Yes / No / Uncertain
  • Red flag: If sustainability uncertain, consider simpler sustainable alternative

Governance Assessment:

☐ Ownership and control

  • Who owns the data? (Government / External partner / Unclear)
  • Data hosted where? (In-country / Cloud / External)
  • Who maintains system? (Local team / Vendor / External partner)
  • Exit strategy: What happens if funding ends? _______________________
  • Red flag: If answers are “External” or “Unclear,” address governance first

Phase 2: Technology Selection (1–2 months)

Decision Framework: Choosing Appropriate AI Solutions

Use this decision tree:

START: What problem are you solving?

├─ STRUCTURED REPORTING (counts, yes/no, select options)
│ ├─ Smartphone penetration >80%?
│ │ └─ YES → Mobile app (ODK, CommCare, DHIS2)
│ │ └─ NO → SMS-based system (RapidPro, FrontlineSMS, mTRAC-style)
│
├─ IMAGE-BASED DIAGNOSIS (X-rays, microscopy, dermatology)
│ ├─ Reliable internet?
│ │ └─ YES → Cloud AI (Azure, AWS, Google)
│ │ └─ NO → On-device AI (TensorFlow Lite, Edge deployment)
│ ├─ Existing imaging equipment quality?
│ │ └─ High → Standard models may work
│ │ └─ Low → Retrain on local equipment + augment for image quality
│
├─ OUTBREAK DETECTION / SURVEILLANCE
│ ├─ Real-time reporting exists?
│ │ └─ YES → Add anomaly detection layer
│ │ └─ NO → First digitize reporting (SMS/app), then add AI
│ ├─ Data quality sufficient?
│ │ └─ YES (>80% complete, timely) → AI feasible
│ │ └─ NO (<80%) → Fix data collection first, AI later
│
├─ RISK PREDICTION / STRATIFICATION
│ ├─ Electronic health records exist?
│ │ └─ YES → Train on local data (performance, fairness crucial)
│ │ └─ NO → Paper-based → Digitize first, AI later
│ ├─ External model available?
│ │ └─ MUST validate on local population before deployment
│ │ └─ Expect a performance drop; measure it, retrain if needed
│
└─ LANGUAGE/TEXT TASKS (translation, information extraction)
 ├─ Language supported by major LLMs?
 │ └─ YES (English, Spanish, French, etc.) → LLMs viable
 │ └─ NO (low-resource language) → Likely requires custom solution
 ├─ PHI involved?
  └─ YES → Local models only (Llama 2, Mistral, on-premise)
  └─ NO → Enterprise LLMs under a data processing agreement that meets local law

Key Selection Principles:

  1. Offline-first when internet unreliable
    • TensorFlow Lite, ONNX Runtime, Edge deployment
    • Data sync when connectivity available
    • Avoid: Cloud-only solutions
  2. Low-power when electricity limited
    • Efficient models (MobileNet, SqueezeNet, quantized models)
    • Battery-powered devices
    • Avoid: High-compute models (GPT-4, large vision models)
  3. Simple when local capacity limited
    • Rule-based systems, statistical methods
    • Transparent, interpretable models
    • Open-source with active communities
    • Avoid: Proprietary black boxes
    • Avoid: Complex deep learning that local teams cannot maintain
  4. Government-owned when sustainability matters
    • In-country data hosting
    • Open-source, customizable
    • Local team trained to maintain
    • Avoid: Vendor lock-in
    • Avoid: Dependency on external servers

Phase 3: Implementation (3–6 months)

Pilot-First Approach:

Months 1–2: Small Pilot (5–10 sites)

  • Select diverse sites (urban/rural, high/low-performing)
  • Intensive support (weekly check-ins)
  • Rapid iteration based on feedback
  • Measure: Usability, data quality, acceptability, early impact

Months 3–4: Expanded Pilot (20–50 sites)

  • Scale to more sites with less intensive support
  • Train local supervisors to provide support
  • Refine training materials based on pilot 1
  • Measure: Same metrics + sustainability indicators

Months 5–6: Regional Scale (100+ sites)

  • Deploy to entire district/region
  • Minimal external support (local team leads)
  • Integrate into routine supervision
  • Measure: All above + cost-effectiveness

Success Criteria for Each Phase:

Metric Pilot 1 Target Pilot 2 Target Scale Target
Adoption rate >80% >85% >90%
Data completeness >75% >85% >90%
Data timeliness <7 days <3 days <24 hours
User satisfaction >70% satisfied >80% satisfied >85% satisfied
System uptime >90% >95% >99%
Cost per site Higher (learning) Decreasing Sustainable

Go/No-Go Decision Points:

After each pilot phase, assess:

If two or more answers are NO, pause, troubleshoot, and revise the deployment before scaling.

Phase 4: Monitoring and Adaptation (Ongoing)

Continuous Improvement Cycle:

Monthly:

  • Usage statistics (adoption, data quality, errors)
  • User feedback (health workers, supervisors, analysts)
  • Technical performance (uptime, response time, accuracy)

Quarterly:

  • Impact assessment (health outcomes, efficiency, cost)
  • Fairness audit (performance across subgroups, facilities)
  • Capacity assessment (local team skills, independence)
  • Financial sustainability check

Annually:

  • Thorough evaluation (peer-reviewed study if possible)
  • Cost-effectiveness analysis
  • Scale-up planning (new regions, new use cases)
  • Technology refresh (update models, infrastructure)
Common Pitfalls to Avoid

1. Technology-First Thinking

  • Avoid: “We have this great AI model, let’s find a problem”
  • Better: “We have this urgent problem, what’s the simplest effective solution?”

2. Pilot Syndrome

  • Avoid: Successful 6-month pilot → funding ends → system abandoned
  • Better: Plan for sustainability from day 1, with government ownership

3. Ignoring Context

  • Avoid: Importing solutions from high-income settings without adaptation
  • Better: Design for local constraints (internet, power, skills, workflows)

4. Over-Engineering

  • Avoid: Complex deep learning when simple statistics would work
  • Better: Start simple, add complexity only if clearly beneficial

5. Poor Data Quality

  • Avoid: Building AI on incomplete, inaccurate, delayed data
  • Better: Fix data collection process first, then add AI

6. Capacity Neglect

  • Avoid: External experts build system, locals cannot maintain after departure
  • Better: Build local capacity from start, plan for handover

7. No Feedback Loop

  • Avoid: Deploy and forget
  • Better: Continuous monitoring, user feedback, iterative improvement

8. Fairness Blindness

  • Avoid: Assuming AI works equally well for all populations
  • Better: Test performance across subgroups, address disparities

DHIS2: The Global Standard for Health Information

DHIS2 (District Health Information Software 2) is the world’s most widely used health information management system, deployed in over 80 countries and covering 3.2 billion people. Understanding DHIS2 is essential for anyone working on AI in LMIC contexts.

Why DHIS2 Matters for AI

Scale and adoption:

  • Used for national health information systems
  • Covers 3.2 billion people (40% of world population)
  • Free, open-source, actively maintained by University of Oslo

AI integration opportunities:

  • Standardized data structure enables cross-country learning
  • API access for automated data extraction and analysis
  • Built-in analytics that AI can augment
  • Community health worker apps (DHIS2 Capture) provide mobile data collection

Common use cases:

  • Disease surveillance and outbreak detection
  • Immunization tracking and coverage analysis
  • Supply chain management and stock prediction
  • Health facility performance monitoring

DHIS2 + AI Integration Patterns

# Example: Extract DHIS2 data for anomaly detection
import requests

def get_dhis2_disease_data(base_url, username, password, dataset_id, period):
    """
    Extract disease surveillance data from DHIS2 for AI analysis
    """
    # DHIS2 API endpoint for analytics
    endpoint = f"{base_url}/api/analytics.json"

    # A list of tuples, because DHIS2 takes repeated 'dimension' parameters
    # and a Python dict would keep only the last one
    params = [
        ('dimension', f'dx:{dataset_id}'),
        ('dimension', f'pe:{period}'),
        ('dimension', 'ou:LEVEL-3'),  # District level
        ('skipMeta', 'true')
    ]

    response = requests.get(
        endpoint,
        params=params,
        auth=(username, password)
    )

    return response.json()

# Feed into anomaly detection pipeline
# disease_data = get_dhis2_disease_data(...)
# anomalies = detect_outbreaks(disease_data)

Resources:

Implementation Evidence from Lao PDR

Lao PDR piloted a DHIS2 Tracker-based electronic immunisation registry in one district hospital in November 2022, expanded it to two provinces in 2023, and completed nationwide rollout in 2024. A mixed-methods evaluation in the two earliest implementation regions combined surveys of 26 healthcare workers, 18 stakeholder interviews, workflow observation, and a data-quality assessment of 849,055 unique vaccination events (Patel et al., 2026).

The evaluation found high user acceptance alongside material data and implementation limits. Vaccine type was missing for 15.66% of events, vaccination date was missing for 14.91%, and only 15.26% of vaccinations were recorded within three days. Workforce capacity, electricity, connectivity, governance, and sustainable financing therefore remain prerequisites for using registry data in forecasting or coverage analysis (Patel et al., 2026).


Simplified AI Vendor Evaluation for Resource-Limited Settings

Health departments with limited technical capacity need a streamlined evaluation process. Use this one-page checklist before adopting any AI tool.

Quick Vendor Evaluation Checklist (1-Page Version)

Before you begin: A NO on any of the first three questions (offline operation, local validation, training burden) ends the evaluation.

Must-Have Requirements (All YES to proceed directly to a pilot)

# Question YES/NO
1 Can the system work offline or with intermittent connectivity?
2 Is the system validated on populations similar to yours?
3 Can your staff operate it with less than 1 week of training?
4 Does the vendor provide local language support?
5 Is pricing transparent and sustainable for your budget?

Red Flags (Any YES = Reconsider)

# Question YES/NO
1 Does the vendor require your data to leave the country?
2 Is the system “black box” with no explainability?
3 Does the contract lock you in for >2 years?
4 Has the vendor never deployed in a similar setting?
5 Does the vendor dismiss questions about bias/fairness?

Key Questions to Ask Vendors

  1. “Where has this been deployed in similar settings?”
    • Get specific country/facility references
    • Contact those sites directly
  2. “What happens when internet is unavailable?”
    • Acceptable: “Works offline, syncs when connected”
    • Unacceptable: “Requires constant connectivity”
  3. “How was the model validated on our population?”
    • Acceptable: “Validated on [similar LMIC population]”
    • Unacceptable: “Validated in US/Europe, should generalize”
  4. “What is the total cost of ownership for 5 years?”
    • Include: licensing, training, maintenance, infrastructure
    • Watch for hidden costs (API calls, storage, support)
  5. “What happens when the contract ends?”
    • Data portability
    • Transition support
    • Local capacity built

Decision Matrix

Score Recommendation
5/5 Must-Have + 0/5 Red Flags Proceed with pilot
4/5 Must-Have or 1 Red Flag, with questions 1–3 all YES Request modifications, re-evaluate
Any NO on questions 1–3, <4 Must-Have, or >1 Red Flag Do not proceed

Algorithmic Fairness Across Populations

The Global Bias Problem

Reality: Most AI health models are trained on data from high-income countries and perform poorly on LMIC populations.

Obermeyer et al., 2019, Science showed that widely-used healthcare algorithms exhibit systematic racial bias.

Examples of Population Bias
  1. Pulse oximetry (a measurement device rather than an AI model, but a common input to AI systems) - Occult hypoxemia went undetected nearly three times as often in Black patients as in White patients (Sjoding et al., 2020, NEJM)

  2. Dermatology AI - Three dermatology models, one published algorithm and two trained by the authors on previously described datasets, reached ROC-AUC 0.56–0.67 on a pathologically confirmed, skin-tone-diverse image set, against 0.88–0.94 on their original test data, and performed worse on Fitzpatrick skin types V–VI than on types I–II (Daneshjou et al., 2022, Science Advances)

  3. Clinical risk algorithms - A widely used algorithm that predicted health costs as a proxy for health need gave Black patients lower risk scores than equally sick White patients (Obermeyer et al., 2019, Science)

  4. Diagnostic imaging - Chest radiograph models identified the hospital system and department where each image was acquired and performed worse on external data than internally in three of five comparisons, so models moved to LMIC sites with different equipment and acquisition conditions need the same external validation (Zech et al., 2018, PLOS Medicine)

  5. Language models - Clinical NLP trained on English medical records fails on other languages

Measuring and Addressing Bias

import numpy as np
import pandas as pd
from sklearn.metrics import accuracy_score, confusion_matrix

class FairnessAuditor:
 """
 Audit AI health models for fairness across populations

 Evaluates performance disparities across:
 - Geographic regions
 - Income levels
 - Ethnicities
 - Languages
 - Healthcare settings
 """

 def audit_model_fairness(self, model, test_data, sensitive_attributes):
  """
  Full fairness audit

  Args:
   model: Trained model to audit
   test_data: Test dataset with ground truth
   sensitive_attributes: List of attributes to check (e.g., ['country', 'ethnicity', 'income_level'])

  Returns:
   Fairness report with performance by subgroup
  """
  results = {}

  # Get predictions
  X = test_data.drop(['label'] + sensitive_attributes, axis=1)
  y_true = test_data['label']
  y_pred = model.predict(X)

  # Overall performance
  overall_accuracy = accuracy_score(y_true, y_pred)
  results['overall'] = {
   'accuracy': overall_accuracy,
   'n_samples': len(y_true)
  }

  # Performance by subgroup
  for attribute in sensitive_attributes:
   results[attribute] = {}

   for group in test_data[attribute].unique():
    mask = test_data[attribute] == group
    group_accuracy = accuracy_score(y_true[mask], y_pred[mask])

    results[attribute][group] = {
     'accuracy': group_accuracy,
     'n_samples': mask.sum(),
     'disparity': group_accuracy - overall_accuracy
    }

  return results

 def calculate_fairness_metrics(self, results):
  """
  Calculate fairness metrics

  Metrics:
  - Max disparity: Largest accuracy difference between any two groups
  - Min accuracy: Lowest accuracy across all groups
  - Accuracy ratio: Ratio of worst to best performing group
  """
  fairness_metrics = {}

  for attribute, groups in results.items():
   if attribute == 'overall':
    continue

   accuracies = [g['accuracy'] for g in groups.values()]

   fairness_metrics[attribute] = {
    'max_disparity': max(accuracies) - min(accuracies),
    'min_accuracy': min(accuracies),
    'max_accuracy': max(accuracies),
    'accuracy_ratio': min(accuracies) / max(accuracies) if max(accuracies) > 0 else 0
   }

  return fairness_metrics

 def generate_fairness_report(self, results, fairness_metrics):
  """Generate human-readable fairness report"""
  report = "=== MODEL FAIRNESS AUDIT ===\n\n"

  # Overall performance
  report += f"Overall Accuracy: {results['overall']['accuracy']:.2%}\n"
  report += f"Total Samples: {results['overall']['n_samples']:,}\n\n"

  # Performance by attribute
  for attribute, groups in results.items():
   if attribute == 'overall':
    continue

   report += f"--- Performance by {attribute.upper()} ---\n"

   for group, metrics in groups.items():
    disparity_indicator = "[OK]" if abs(metrics['disparity']) < 0.05 else "[WARNING]"
    report += f"{disparity_indicator} {group}: {metrics['accuracy']:.2%} "
    report += f"(n={metrics['n_samples']:,}, "
    report += f"disparity: {metrics['disparity']:+.1%})\n"

   # Fairness metrics for this attribute
   fm = fairness_metrics[attribute]
   report += f"\n Max disparity: {fm['max_disparity']:.1%}\n"
   report += f" Accuracy ratio: {fm['accuracy_ratio']:.2f}\n"

   # Flag if fairness issue detected
   if fm['max_disparity'] > 0.10:
    report += f" [WARNING] Large performance disparity detected (>{10}%)\n"
   elif fm['max_disparity'] > 0.05:
    report += f" [WARNING] Moderate performance disparity detected (>{5}%)\n"
   else:
    report += f" [OK] Fairness check passed\n"

   report += "\n"

  return report

# Example: Audit sepsis prediction model across populations

# Simulate test data from multiple countries
test_data = pd.DataFrame({
 'feature1': np.random.randn(10000),
 'feature2': np.random.randn(10000),
 'label': np.random.randint(0, 2, 10000),
 'country': np.random.choice(['USA', 'Kenya', 'India', 'Brazil'], 10000),
 'income_level': np.random.choice(['High', 'Upper-middle', 'Lower-middle', 'Low'], 10000),
 'healthcare_setting': np.random.choice(['Urban_hospital', 'Rural_clinic'], 10000)
})

# Audit model
auditor = FairnessAuditor()
results = auditor.audit_model_fairness(
 model=sepsis_model,
 test_data=test_data,
 sensitive_attributes=['country', 'income_level', 'healthcare_setting']
)

# Calculate fairness metrics
fairness_metrics = auditor.calculate_fairness_metrics(results)

# Generate report
report = auditor.generate_fairness_report(results, fairness_metrics)
print(report)

Example output (illustrative values, not drawn from one consistent dataset):

=== MODEL FAIRNESS AUDIT ===

Overall Accuracy: 87.3%
Total Samples: 10,000

--- Performance by COUNTRY ---
[OK] USA: 91.2% (n=2,523, disparity: +3.9%)
[WARNING] Kenya: 78.5% (n=2,491, disparity: -8.8%)
[WARNING] India: 80.1% (n=2,478, disparity: -7.2%)
[OK] Brazil: 88.4% (n=2,508, disparity: +1.1%)

 Max disparity: 12.7%
 Accuracy ratio: 0.86
 [WARNING] Large performance disparity detected (>10%)

--- Performance by INCOME_LEVEL ---
[OK] High: 90.5% (n=2,534, disparity: +3.2%)
[OK] Upper-middle: 88.1% (n=2,512, disparity: +0.8%)
[OK] Lower-middle: 84.2% (n=2,467, disparity: -3.1%)
[WARNING] Low: 79.3% (n=2,487, disparity: -8.0%)

 Max disparity: 11.2%
 Accuracy ratio: 0.88
 [WARNING] Large performance disparity detected (>10%)

Strategies to Improve Fairness

1. Diverse Training Data

Problem: Models trained only on high-income country data perform poorly elsewhere.

Solution: Include diverse training data from multiple populations.

class DiverseDatasetBuilder:
 """
 Build diverse training datasets that represent global populations
 """

 @staticmethod
 def assess_dataset_diversity(dataset, dimensions=['country', 'income_level', 'ethnicity']):
  """
  Assess diversity of existing dataset

  Returns representation across key dimensions
  """
  diversity_report = {}

  for dim in dimensions:
   if dim in dataset.columns:
    # Calculate representation
    counts = dataset[dim].value_counts()
    proportions = counts / len(dataset)

    diversity_report[dim] = {
     'n_categories': len(counts),
     'distribution': proportions.to_dict(),
     'entropy': -sum(proportions * np.log2(proportions)), # Higher = more diverse
     'min_representation': proportions.min(),
     'max_representation': proportions.max()
    }

  return diversity_report

 @staticmethod
 def balance_dataset(dataset, target_attribute, strategy='oversample'):
  """
  Balance dataset to ensure fair representation

  Strategies:
  - oversample: Duplicate underrepresented samples
  - undersample: Remove overrepresented samples
  - synthetic: Generate synthetic samples (SMOTE-like)
  """
  from sklearn.utils import resample

  if strategy == 'oversample':
   # Find maximum class size
   max_size = dataset[target_attribute].value_counts().max()

   # Oversample each group to max size
   balanced_groups = []
   for group in dataset[target_attribute].unique():
    group_data = dataset[dataset[target_attribute] == group]
    group_upsampled = resample(
     group_data,
     n_samples=max_size,
     replace=True, # Allow duplicates
     random_state=42
    )
    balanced_groups.append(group_upsampled)

   balanced_dataset = pd.concat(balanced_groups)

  elif strategy == 'undersample':
   # Find minimum class size
   min_size = dataset[target_attribute].value_counts().min()

   # Undersample each group to min size
   balanced_groups = []
   for group in dataset[target_attribute].unique():
    group_data = dataset[dataset[target_attribute] == group]
    group_downsampled = resample(
     group_data,
     n_samples=min_size,
     replace=False,
     random_state=42
    )
    balanced_groups.append(group_downsampled)

   balanced_dataset = pd.concat(balanced_groups)

  return balanced_dataset

 @staticmethod
 def create_stratified_split(dataset, test_size=0.2, stratify_by=['country', 'income_level']):
  """
  Create train/test split that preserves diversity

  Ensures test set represents all populations
  """
  from sklearn.model_selection import train_test_split

  # Create combined stratification key
  dataset['_strat_key'] = dataset[stratify_by].apply(
   lambda x: '_'.join(x.astype(str)),
   axis=1
  )

  # Stratified split
  train, test = train_test_split(
   dataset,
   test_size=test_size,
   stratify=dataset['_strat_key'],
   random_state=42
  )

  # Remove stratification key
  train = train.drop('_strat_key', axis=1)
  test = test.drop('_strat_key', axis=1)

  return train, test

# Example: Build diverse dataset for global sepsis prediction

# Assess current dataset diversity
builder = DiverseDatasetBuilder()
diversity_report = builder.assess_dataset_diversity(
 training_data,
 dimensions=['country', 'income_level', 'healthcare_setting']
)

print("Current dataset diversity:")
for dim, metrics in diversity_report.items():
 print(f"\n{dim}:")
 print(f" Categories: {metrics['n_categories']}")
 print(f" Entropy: {metrics['entropy']:.2f} (max: {np.log2(metrics['n_categories']):.2f})")
 print(f" Min representation: {metrics['min_representation']:.1%}")
 print(f" Max representation: {metrics['max_representation']:.1%}")

# Balance dataset to ensure fair representation
balanced_data = builder.balance_dataset(
 training_data,
 target_attribute='country',
 strategy='oversample'
)

# Create stratified train/test split
train, test = builder.create_stratified_split(
 balanced_data,
 stratify_by=['country', 'income_level']
)

print(f"\nDataset sizes:")
print(f" Training: {len(train):,} samples")
print(f" Testing: {len(test):,} samples")

2. Fairness-Aware Training

Problem: Standard training optimizes overall accuracy, which may achieve high accuracy on majority populations at the expense of minority populations.

Solution: Train with fairness constraints.

class FairML:
 """
 Train models with fairness constraints
 """

 @staticmethod
 def train_with_fairness_constraint(
  X_train, y_train, sensitive_attribute,
  fairness_metric='demographic_parity',
  constraint_threshold=0.05
 ):
  """
  Train model that satisfies fairness constraints

  Fairness metrics:
  - demographic_parity: P(ŷ=1 | A=0) ≈ P(ŷ=1 | A=1)
  - equalized_odds: TPR and FPR equal across groups
  - equal_opportunity: TPR equal across groups

  Uses: Fairlearn library
  """
  from fairlearn.reductions import ExponentiatedGradient, DemographicParity, EqualizedOdds
  from sklearn.linear_model import LogisticRegression

  # Base model
  base_model = LogisticRegression()

  # Choose fairness constraint
  if fairness_metric == 'demographic_parity':
   constraint = DemographicParity()
  elif fairness_metric == 'equalized_odds':
   constraint = EqualizedOdds()

  # Train with fairness constraint
  fair_model = ExponentiatedGradient(
   base_model,
   constraints=constraint
  )

  fair_model.fit(X_train, y_train, sensitive_features=sensitive_attribute)

  return fair_model

 @staticmethod
 def post_process_for_fairness(model, X_test, y_test, sensitive_attribute):
  """
  Adjust prediction thresholds to achieve fairness

  Post-processing approach: Different thresholds for different groups
  """
  from fairlearn.postprocessing import ThresholdOptimizer

  # Get model predictions (probabilities)
  y_pred_proba = model.predict_proba(X_test)[:, 1]

  # Optimize thresholds for fairness
  threshold_optimizer = ThresholdOptimizer(
   estimator=model,
   constraints='demographic_parity'
  )

  threshold_optimizer.fit(X_test, y_test, sensitive_features=sensitive_attribute)

  # Apply optimized thresholds
  y_pred_fair = threshold_optimizer.predict(
   X_test,
   sensitive_features=sensitive_attribute
  )

  return y_pred_fair

# Example: Train fair sepsis prediction model

# Train standard model
standard_model = LogisticRegression()
standard_model.fit(X_train, y_train)

# Train fair model
fair_ml = FairML()
fair_model = fair_ml.train_with_fairness_constraint(
 X_train, y_train,
 sensitive_attribute=sensitive_train['country'],
 fairness_metric='equalized_odds'
)

# Compare fairness
auditor = FairnessAuditor()

print("Standard Model:")
standard_results = auditor.audit_model_fairness(
 standard_model, test_data, ['country']
)
print(auditor.generate_fairness_report(standard_results,
          auditor.calculate_fairness_metrics(standard_results)))

print("\nFair Model:")
fair_results = auditor.audit_model_fairness(
 fair_model, test_data, ['country']
)
print(auditor.generate_fairness_report(fair_results,
          auditor.calculate_fairness_metrics(fair_results)))

3. Local Fine-Tuning

Problem: Global model trained on diverse data may still not perform optimally in specific local contexts.

Solution: Fine-tune on local data while retaining global knowledge.

class LocalFineTuner:
 """
 Fine-tune global models on local data

 Approach: Transfer learning - start with global model, adapt to local context
 """

 @staticmethod
 def fine_tune(global_model, local_X, local_y, n_epochs=10):
  """
  Fine-tune global model on local data

  Uses small learning rate to avoid catastrophic forgetting
  """
  import tensorflow as tf

  # Freeze early layers (retain global knowledge)
  for layer in global_model.layers[:-3]:
   layer.trainable = False

  # Recompile with small learning rate
  global_model.compile(
   optimizer=tf.keras.optimizers.Adam(learning_rate=0.0001), # 10x smaller
   loss='binary_crossentropy',
   metrics=['accuracy']
  )

  # Fine-tune on local data
  history = global_model.fit(
   local_X, local_y,
   epochs=n_epochs,
   batch_size=32,
   validation_split=0.2,
   verbose=0
  )

  return global_model

 @staticmethod
 def ensemble_global_local(global_model, local_model, X, alpha=0.7):
  """
  Ensemble global and local models

  Combines global knowledge with local expertise

  Args:
   alpha: Weight for global model (0.7 = 70% global, 30% local)
  """
  # Get predictions from both models
  global_pred = global_model.predict(X)
  local_pred = local_model.predict(X)

  # Weighted ensemble
  ensemble_pred = alpha * global_pred + (1 - alpha) * local_pred

  return ensemble_pred

# Example: Deploy global model in Kenya, fine-tune on local data

# Start with global model (trained on data from 50 countries)
global_model = load_pretrained_model('global_sepsis_model.h5')

# Collect local data (Kenya)
kenya_data = collect_local_data(country='Kenya', n_samples=500)

# Fine-tune on Kenyan data
tuner = LocalFineTuner()
kenya_model = tuner.fine_tune(
 global_model,
 kenya_data['X'],
 kenya_data['y'],
 n_epochs=20
)

# Evaluate on Kenyan test set
kenya_test = load_test_data(country='Kenya')

global_performance = evaluate_model(global_model, kenya_test)
local_performance = evaluate_model(kenya_model, kenya_test)

print("Kenya Performance:")
print(f" Global model: {global_performance['accuracy']:.1%} accuracy")
print(f" Fine-tuned model: {local_performance['accuracy']:.1%} accuracy")
print(f" Improvement: {local_performance['accuracy'] - global_performance['accuracy']:.1%}")

Building Local AI Capacity

The Capacity Challenge

Current state: AI research capacity, companies, compute, and health-data infrastructure are geographically concentrated. The degree of concentration depends on the metric and dataset.

Consequence: Dependence on external solutions that may not fit local needs.

Solution: Build local capacity for AI development, deployment, and governance.

Capacity Building Framework

class CapacityBuildingProgram:
 """
 Framework for building AI capacity in LMIC settings

 Levels:
 1. Awareness: Understanding what AI is and its potential
 2. Literacy: Basic understanding of AI concepts
 3. Application: Ability to use existing AI tools
 4. Development: Ability to develop AI solutions
 5. Research: Ability to conduct AI research and innovation
 """

 def __init__(self, context):
  self.context = context # Country/region context
  self.current_capacity = self.assess_capacity()
  self.target_capacity = self.define_targets()

 def assess_capacity(self):
  """
  Assess current AI capacity

  Dimensions:
  - Human capital (skills, education)
  - Infrastructure (hardware, connectivity)
  - Data (availability, quality, governance)
  - Partnerships (academic, industry, government)
  - Policy (regulation, funding, strategy)
  """
  assessment = {
   'human_capital': {
    'data_scientists': 0, # Number of data scientists
    'ai_researchers': 0, # Number of AI researchers
    'ai_trained_health_workers': 0, # Health workers with AI training
    'ai_education_programs': 0 # University AI programs
   },
   'infrastructure': {
    'computing_resources': 'none', # none/limited/adequate
    'internet_connectivity': 0.0, # % population with internet
    'cloud_access': False, # Access to cloud platforms
    'data_infrastructure': 'paper' # paper/digital/interoperable
   },
   'data': {
    'ehr_penetration': 0.0, # % facilities with EHR
    'data_quality': 'low', # low/medium/high
    'data_governance': False, # Data governance framework exists
    'open_datasets': 0 # Number of open health datasets
   },
   'partnerships': {
    'academic_collaborations': 0, # Number of collaborations
    'industry_partnerships': 0,
    'government_support': False
   },
   'policy': {
    'ai_strategy': False, # National AI strategy exists
    'health_ai_policy': False, # Health-specific AI policy
    'funding': 0, # Annual AI R&D funding
    'regulations': False # AI regulations in place
   }
  }

  return assessment

 def define_targets(self, timeline_years=5):
  """
  Define capacity building targets

  Realistic, achievable targets over 5 years
  """
  targets = {
   'human_capital': {
    'train_data_scientists': 100, # Train 100 local data scientists
    'train_health_workers': 1000, # 1000 health workers with AI literacy
    'establish_ai_programs': 3, # 3 university AI programs
    'scholarships': 50 # 50 scholarships for AI education
   },
   'infrastructure': {
    'establish_compute_centers': 2, # 2 regional compute centers
    'cloud_partnerships': ['AWS', 'Google', 'Azure'], # Cloud credits
    'expand_ehr': 0.50, # 50% EHR penetration
    'improve_connectivity': 0.70 # 70% internet access
   },
   'data': {
    'create_open_datasets': 10, # 10 open health datasets
    'establish_governance': True, # Data governance framework
    'improve_quality': 'medium', # Medium quality data
    'data_sharing_agreements': 5 # 5 international data sharing agreements
   },
   'partnerships': {
    'academic_collaborations': 20, # 20 academic partnerships
    'industry_partnerships': 10, # 10 industry partnerships
    'government_investment': True # Secure government funding
   },
   'policy': {
    'develop_ai_strategy': True,
    'develop_health_ai_policy': True,
    'establish_funding': 5000000, # $5M annual funding
    'develop_regulations': True
   }
  }

  return targets

 def create_training_program(self, level='application'):
  """
  Design training program for different levels

  Levels:
  - awareness: 1-day workshop
  - literacy: 1-week course
  - application: 3-month bootcamp
  - development: 6-month intensive program
  - research: 2-year fellowship
  """
  programs = {
   'awareness': {
    'duration': '1 day',
    'audience': 'Health policymakers, administrators',
    'content': [
     'What is AI? Demystifying artificial intelligence',
     'AI applications in public health (case studies)',
     'Opportunities and risks in our context',
     'Policy and ethical considerations'
    ],
    'format': 'Workshop with interactive demos',
    'outcome': 'Understanding of AI potential and challenges'
   },
   'literacy': {
    'duration': '1 week (40 hours)',
    'audience': 'Health professionals, program managers',
    'content': [
     'Day 1: AI fundamentals and terminology',
     'Day 2: Machine learning basics (supervised, unsupervised)',
     'Day 3: AI in healthcare (diagnosis, prediction, optimization)',
     'Day 4: Data quality and ethics',
     'Day 5: Evaluating AI tools and vendors'
    ],
    'format': 'Lectures + hands-on demos (no coding)',
    'outcome': 'Ability to evaluate and procure AI solutions'
   },
   'application': {
    'duration': '3 months (part-time, 10 hours/week)',
    'audience': 'Health data analysts, informaticians',
    'content': [
     'Month 1: Python for data analysis',
     'Month 2: Machine learning with scikit-learn',
     'Month 3: Applied project with real health data'
    ],
    'format': 'Online course + local mentorship + capstone project',
    'outcome': 'Ability to apply ML to local health problems'
   },
   'development': {
    'duration': '6 months (full-time)',
    'audience': 'Software developers, data scientists (career transition)',
    'content': [
     'Months 1-2: ML fundamentals (theory + practice)',
     'Months 3-4: Deep learning (TensorFlow, PyTorch)',
     'Months 5-6: Health AI applications + capstone project'
    ],
    'format': 'Intensive bootcamp + industry mentorship',
    'outcome': 'Ability to develop AI solutions from scratch'
   },
   'research': {
    'duration': '2 years (full-time)',
    'audience': 'PhD students, early-career researchers',
    'content': [
     'Year 1: Advanced ML, research methods, literature review',
     'Year 2: Original research project, publication'
    ],
    'format': 'Fellowship with international university partnership',
    'outcome': 'Ability to conduct original AI research'
   }
  }

  return programs.get(level, programs['application'])

# Example: Implement capacity building program in Rwanda

program = CapacityBuildingProgram(context='Rwanda')

# Assess current capacity
capacity = program.assess_capacity()
print("Current Capacity Assessment:")
print(f" Data scientists: {capacity['human_capital']['data_scientists']}")
print(f" Internet penetration: {capacity['infrastructure']['internet_connectivity']:.0%}")
print(f" EHR penetration: {capacity['data']['ehr_penetration']:.0%}")

# Define targets
targets = program.define_targets(timeline_years=5)
print("\n5-Year Targets:")
print(f" Train {targets['human_capital']['train_data_scientists']} data scientists")
print(f" Establish {targets['human_capital']['establish_ai_programs']} AI programs")
print(f" Create {targets['data']['create_open_datasets']} open health datasets")

# Design training programs
print("\nTraining Programs:")
for level in ['awareness', 'literacy', 'application', 'development']:
 program_details = program.create_training_program(level)
 print(f"\n{level.upper()}:")
 print(f" Duration: {program_details['duration']}")
 print(f" Audience: {program_details['audience']}")
 print(f" Outcome: {program_details['outcome']}")

Successful Capacity Building Models

1. Data Science for Social Good (DSSG)

Model: Bring together data scientists, social scientists, and domain experts for 3-month intensive projects addressing social challenges.

Global health applications: Programs of this type can use supervised projects in surveillance, service delivery, or maternal health.

Key elements:

  • Hands-on learning - Real projects with real data
  • Mentorship - Pairing with experienced data scientists
  • Impact focus - Solutions deployed after program
  • Local partnership - Work with local health authorities

2. AI4D Africa

Model: Pan-African network supporting AI research and innovation relevant to African contexts.

Initiatives: Research grants, compute access, workshops, mentorship, and research networks can support locally led work.

3. Makerere AI Lab (Uganda)

Model: University-based AI research lab focused on local problems.

Projects:

  • Air quality monitoring - Low-cost sensors + ML for Kampala air quality
  • Crop disease detection - Smartphone app for farmers
  • Malaria prediction - Early warning system

Impact: The lab provides an example of university-based, locally led research.


Workforce and Employment Implications

AI’s Impact on Healthcare Employment

The adoption of AI to automate healthcare processes carries labor implications that differ by income level: exposure is lower in low-income countries today, but slower adoption there could widen inequality later. While AI deployment promises efficiency gains, understanding who benefits and who bears costs remains critical for equitable implementation.

Current AI Exposure by Income Level

AI exposure in employment (ILO, 2025):

  • Low-income countries: 11% of total employment exposed to AI
  • High-income countries: 34% of total employment exposed to AI

Potential for AI-enhanced productivity:

  • Low-income countries: 10.4% of jobs could benefit from AI augmentation
  • High-income countries: 13.4% of jobs could benefit from AI augmentation

Short-Term vs. Long-Term Impacts

Immediate effects (2025–2030):

AI exposure is lower in low-income countries, suggesting immediate displacement will be less pronounced than in high-income nations. However, this creates a paradox: limited AI adoption now may widen income disparities later.

Long-term projections:

While fewer jobs may be displaced in LMICs in the short term, income inequality could widen if high-income countries capture AI productivity gains while LMICs lag in adoption and skill development.

Jobs at Risk and Opportunities

Vulnerable roles:

AI deployment in triage, documentation, and basic patient communication may displace lower-wage healthcare and administrative jobs, particularly:

  • Community health workers performing routine triage
  • Call center agents handling basic health inquiries
  • Administrative staff managing appointment scheduling and basic documentation
  • Data entry personnel processing paper records

Emerging opportunities:

  • AI oversight and monitoring roles
  • Data annotation and quality assurance for local models
  • Technical support for AI-integrated health systems
  • Training and change management specialists

Telemedicine and Wage Dynamics

The COVID-19 pandemic accelerated telemedicine adoption, creating divergent wage effects:

High-income countries:

  • Increased remuneration for telehealth specialists
  • Expanded access to remote consulting opportunities
  • Growing demand for digital health expertise

LMICs:

  • Limited adoption due to inadequate digital infrastructure
  • Lower patient acceptance of remote care
  • Infrastructure barriers prevent participation in global telehealth markets

This pattern risks concentrating AI-enabled productivity gains in already-privileged settings while underserved regions miss opportunities for workforce development.

The British eConsult experience shows how digital access tools can scale quickly without becoming evenly distributed. In an observational analysis of 43,657,891 online consultations across England, Scotland, and Wales from 2019 to 2023, Kerr et al. found peak active eConsult coverage of 43.7% of English practices, 11.6% of Scottish practices, and 50.5% of Welsh practices, with higher rates in more affluent areas and 7.7% redirected toward urgent or emergency care (Kerr et al., 2025). For public health AI, the implementation lesson is that digital front doors need standardized recording, equity monitoring, and escalation audits before they are treated as access improvements.

Ethical Concerns: Value Capture and Reallocation

The equity paradox:

  • Job displacement may occur in resource-constrained settings
  • Economic value is captured elsewhere (by technology developers, high-income healthcare systems)
  • Benefits accrue to populations least affected by displacement

Example:

AI-powered triage systems deployed in LMIC clinics may reduce demand for community health workers. If these workers lack retraining pathways, they face unemployment while the efficiency gains benefit health systems or technology vendors in other contexts.

Preparing the Workforce

Proactive training now prevents disruption later:

The low AI exposure in LMICs offers a window of opportunity to prepare health systems before widespread AI adoption. Key strategies:

  1. Integrate AI literacy into existing training pipelines:
    • Medical and nursing curricula
    • Continuing professional development for practicing clinicians
    • Public health program requirements
  2. Skill development for AI oversight:
    • Critical assessment of AI-generated recommendations
    • Recognizing hallucinations and errors
    • Understanding when to override AI suggestions
  3. Technical capacity building:
    • Data science training for health informatics professionals
    • AI deployment and maintenance skills
    • Local customization and fine-tuning expertise
  4. Transition support for affected roles:
    • Reskilling programs for administrative staff
    • Community health worker evolution to AI-augmented roles
    • Career pathways in digital health

Avoiding Perpetual Vigilance Traps

Critical design principle:

Assigning humans to supervise AI through constant monitoring is suboptimal. Humans are poor at sustained vigilance tasks, which can increase rather than reduce errors.

Better approaches:

  • Design AI-clinician partnerships beyond passive oversight
  • Implement active collaboration models where AI handles routine tasks while humans focus on complex decision-making
  • Avoid reliance on human vigilance as primary safety mechanism

Policy Considerations

For health system leaders:

  • Conduct workforce impact assessments before large-scale AI deployment
  • Establish transition support and retraining programs
  • Ensure affected workers have pathways to AI-augmented roles
  • Monitor job quality, not just quantity (wages, working conditions, autonomy)

For governments:

  • Invest in digital literacy and AI education infrastructure
  • Create safety nets for workers displaced by automation
  • Incentivize companies to invest in workforce development, not just deployment
  • Ensure AI productivity gains are broadly shared, not concentrated among technology owners

For international organizations:

  • Support LMIC workforce development initiatives
  • Fund skills training and capacity building programs
  • Promote equitable benefit sharing from AI productivity gains
  • Monitor and report on AI’s employment effects globally

Key Takeaways

  • AI exposure is lower in LMICs now, but this creates future inequality risk if capacity building lags
  • Job displacement may affect lower-wage healthcare and administrative roles disproportionately
  • Telemedicine wage dynamics favor high-income countries, widening global health workforce disparities
  • Proactive workforce preparation is essential during the current window of lower AI exposure
  • Design AI-human collaboration thoughtfully, avoiding reliance on sustained human vigilance
  • Equitable AI deployment requires intentional benefit sharing, not just technical implementation

Data Governance in Global Health

The Governance Challenge

Issue: International health collaborations involve data sharing across borders, raising questions about:

  • Sovereignty: Who owns health data? Who controls it?
  • Privacy: How to protect individual privacy across jurisdictions?
  • Benefit sharing: How to ensure LMICs benefit from research using their data?
  • Capacity: How to ensure fair partnerships when capacity is unequal?

Data Colonialism Risk

Data Colonialism

Data colonialism refers to the extraction of data from LMICs by high-income countries or companies for their benefit, with limited benefit to the source populations.

Examples:

  • Genomic data collected from African populations, stored in Western biobanks, used for drug development that benefits high-income populations
  • Health data from LMIC electronic health records used to train commercial AI models sold back to LMICs at high prices
  • Research collaborations where LMIC partners collect data but have no say in how it is used

Result: Value extraction without benefit sharing, repeating colonial patterns in the digital age.

Principles for Equitable Data Governance

import json

class EquitableDataGovernance:
 """
 Framework for equitable data governance in global health AI

 Based on:
 - CARE Principles (Collective benefit, Authority to control, Responsibility, Ethics)
 - FAIR Principles (Findable, Accessible, Interoperable, Reusable)
 - Data sovereignty principles
 """

 def __init__(self, data_source_country, data_user):
  self.data_source = data_source_country
  self.data_user = data_user
  self.governance_framework = self.create_framework()

 def create_framework(self):
  """
  Create data governance framework

  Covers:
  - Consent and authorization
  - Data access and use
  - Benefit sharing
  - Capacity building
  - Intellectual property
  """
  framework = {
   'consent_authorization': {
    'individual_consent': 'Required for identifiable data',
    'community_consent': 'Required for community-level data',
    'institutional_authorization': 'Required from data source institution',
    'government_authorization': 'May be required for export'
   },
   'data_access_use': {
    'data_location': 'Preference for local storage and processing',
    'data_transfer': 'Minimize cross-border transfer when possible',
    'access_control': 'Source institution retains access control',
    'use_restrictions': 'Data use limited to agreed purposes',
    'secondary_use': 'Requires additional authorization',
    'commercial_use': 'Requires separate agreement with benefit sharing'
   },
   'benefit_sharing': {
    'authorship': 'Local partners as co-authors on all publications',
    'ip_sharing': 'Joint IP ownership for innovations',
    'revenue_sharing': 'Royalties from commercial applications',
    'capacity_building': 'Commitment to train local team',
    'data_return': 'Analysis results returned to source community'
   },
   'capacity_building': {
    'training': 'Local team trained in AI methods',
    'infrastructure': 'Investment in local computing infrastructure',
    'sustainability': 'Plan for local capacity to continue work',
    'knowledge_transfer': 'Code, models, documentation shared with local team'
   },
   'intellectual_property': {
    'ownership': 'Joint ownership of AI models and algorithms',
    'licensing': 'Preferential licensing to source country',
    'patents': 'Joint patents with benefit sharing',
    'open_source': 'Preference for open-source when possible'
   }
  }

  return framework

 def create_data_sharing_agreement(self):
  """
  Template for equitable data sharing agreement

  Illustrative template; adapt terms to local law and negotiated priorities
  """
  agreement = f"""
  DATA SHARING AGREEMENT

  Between: {self.data_source} (Data Source)
  And: {self.data_user} (Data User)

  1. DATA DESCRIPTION
  [Describe data: type, volume, collection methods, etc.]

  2. PURPOSE
  [Specific research questions or applications]

  3. DATA ACCESS AND USE
  - Data will be stored in {self.data_source} or mutually agreed secure location
  - {self.data_user} granted access for specified purposes only
  - Any additional use requires written approval from {self.data_source}
  - Data cannot be shared with third parties without written approval

  4. GOVERNANCE
  - Joint steering committee with equal representation
  - {self.data_source} retains ultimate authority over data use
  - Disputes resolved through [mediation process]

  5. CAPACITY BUILDING
  - {self.data_user} commits to train [X] local data scientists
  - Investment of $[Y] in local computing infrastructure
  - All code, models, and documentation shared with {self.data_source}
  - Plan for sustainable local capacity within [Z] years

  6. INTELLECTUAL PROPERTY
  - Joint ownership of all AI models and algorithms
  - Joint authorship on all publications
  - Patents filed jointly with 50/50 ownership
  - Preferential licensing to {self.data_source} for local use

  7. BENEFIT SHARING
  - {self.data_source} researchers co-authors on all publications
  - 50% of any commercial revenue returned to {self.data_source}
  - AI tools made available to {self.data_source} at no cost
  - Analysis results returned to source communities

  8. PRIVACY AND SECURITY
  - Data de-identified per {self.data_source} regulations
  - Security measures: [encryption, access controls, audit logs]
  - Compliance with {self.data_source} data protection laws

  9. DURATION AND TERMINATION
  - Agreement valid for [X] years
  - {self.data_source} can terminate with 30 days' notice
  - Upon termination, {self.data_user} deletes all data

  10. ACCOUNTABILITY
  - Annual progress reports to {self.data_source}
  - External evaluation at [Y] years
  - Community advisory board provides oversight
  """

  return agreement

 def assess_partnership_equity(self):
  """
  Assess whether partnership is equitable

  Red flags:
  - Data source has no say in data use
  - No local capacity building
  - No benefit sharing
  - One-way knowledge transfer
  - Exploitative authorship practices
  """
  assessment = {
   'data_control': {
    'question': 'Does data source retain control over data use?',
    'red_flag': 'Data user has unilateral control',
    'green_flag': 'Data source retains ultimate authority'
   },
   'capacity_building': {
    'question': 'Is there meaningful capacity building?',
    'red_flag': 'No training or infrastructure investment',
    'green_flag': 'Substantial investment in local capacity'
   },
   'benefit_sharing': {
    'question': 'Are benefits shared equitably?',
    'red_flag': 'All benefits go to data user',
    'green_flag': 'Benefits shared through authorship, IP, revenue'
   },
   'knowledge_transfer': {
    'question': 'Is knowledge transferred to source?',
    'red_flag': 'One-way transfer (data out, nothing back)',
    'green_flag': 'Code, models, methods shared with source'
   },
   'sustainability': {
    'question': 'Will local capacity be sustainable?',
    'red_flag': 'Dependent on external expertise indefinitely',
    'green_flag': 'Clear path to local ownership and sustainability'
   }
  }

  return assessment

# Example: Assess proposed data partnership

governance = EquitableDataGovernance(
 data_source_country='Kenya',
 data_user='University of Example'
)

# Check framework
framework = governance.create_framework()
print("Data Governance Framework:")
print(json.dumps(framework, indent=2))

# Generate agreement template
agreement = governance.create_data_sharing_agreement()
print("\nData Sharing Agreement Template:")
print(agreement)

# Assess partnership equity
equity_assessment = governance.assess_partnership_equity()
print("\nPartnership Equity Assessment:")
for dimension, criteria in equity_assessment.items():
 print(f"\n{dimension.upper()}:")
 print(f" Question: {criteria['question']}")
 print(f" Red flag: {criteria['red_flag']}")
 print(f" Green flag: {criteria['green_flag']}")

Large Language Models in Global Public Health

Large language models (LLMs) differ from the narrow AI systems described in Context-Appropriate AI Design. Unlike task-specific diagnostic tools (chest X-ray AI, malaria detection), LLMs are general-purpose language systems that can support surveillance reporting, outbreak communications, health education, community health worker triage, and population health decision support through natural language interaction.

This versatility makes LLMs particularly relevant for public health in resource-limited settings: they can potentially address multiple gaps simultaneously (surveillance, communication, triage), augment overstretched public health workforces, and scale to diverse populations without task-specific retraining. However, this same flexibility creates distinct risks, including hallucinations (confident but false information), privacy concerns with population health data, and deployment challenges that differ from those of narrow AI systems.

African Evidence: Trials and Benchmarks Answer Different Questions

Two 2026 examples show why local evidence must be matched to the claim. A pragmatic cluster-randomized trial in Kenyan primary care evaluated generative AI decision support in routine facilities. Several expert-rated process measures improved, but the prespecified 14-day treatment-failure outcome did not differ significantly, so the study does not establish improved patient outcomes (Agweyu et al., 2026).

IyawoBench evaluates triage decisions for synthetic febrile-illness cases derived from Nigerian primary-care distributions. Its local disease context is useful, but synthetic cases, limited reference labeling, and a fixed evaluation design do not establish prospective safety. The v2 update adds measures for escalation, downgrade, middle-tier instability, and expected deployment cost, which should be interpreted with the original benchmark rather than as an independent validation (Gabriel et al., 2026, preprint; Gabriel and Olawuyi, 2026, preprint).

Together, these studies support a staged program: locally grounded benchmarks for failure discovery, independent clinician labeling and transportability testing, then prospective comparison of workflow, safety, resource use, equity, and patient outcomes. The evaluation framework is detailed in Evaluating AI in Public Health Practice.

Open-Weight Models: Opportunity for Public Health Systems

Computational efficiency for resource-constrained health departments:

Open-weight LLMs such as DeepSeek, Llama 3, and Mistral offer promise for public health agencies with limited IT budgets by dramatically reducing computational requirements and costs while achieving performance comparable to proprietary models (Ong et al., Nature Health, 2026).

DeepSeek deployment in health systems:

DeepSeek, developed under hardware access limitations, has been deployed in 90 Chinese tertiary hospitals since January 2025 for clinical decision support, patient communication, and administrative functions. For public health applications, the key advantage is cost: estimated at only 6.71% of proprietary model costs (OpenAI o1), making LLM capabilities accessible to health departments that cannot afford enterprise AI contracts (Chen et al., Journal of Medical Systems, 2025).

The “too fast, too soon” warning applies to public health:

Chinese medical researchers have raised substantial concerns about rapid deployment without adequate validation (Zeng et al., JAMA, 2025). These concerns extend to public health applications: using LLMs for surveillance triage, outbreak communications, or policy recommendations without prospective validation could lead to systematic errors at population scale.

Public health deployment considerations:

Advantage for Public Health Risk for Public Health
Cost efficiency: Accessible to under-resourced health departments Safety monitoring gaps: Population-scale errors if hallucinations go undetected
Local deployment: Can run on health department servers, protecting sensitive surveillance data Integration complexity: Requires technical capacity often limited in smaller health departments
No vendor lock-in: Avoids dependency on commercial platforms that may discontinue public health pricing Version control challenges: No centralized updates across decentralized public health systems
Customization potential: Can be fine-tuned on local disease patterns, languages, cultural contexts Hallucination risks in communications: False health information at scale during outbreaks

Public health implication:

Open-weight LLMs offer genuine opportunity to extend public health capacity in resource-limited settings, but deployment must include rigorous validation on public health tasks (surveillance coding, risk communication, triage accuracy) with human oversight. The rapid scale-up in clinical settings without prospective trials offers a cautionary example for public health.

LLM-Enhanced Public Health Applications

MomConnect Enhanced with LLMs: SMS-Based Maternal Health at Scale

MomConnect in South Africa has provided maternal-health messaging at national scale. A later program added language-model support for identifying potentially urgent inbound messages while preserving human escalation (Ong et al., 2026). These are distinct stages of the program and should not be treated as one evaluated intervention.

Public health implementation:

  • Base system remains SMS: Preserves accessibility for users with basic feature phones (no smartphone required, works on 2G networks)
  • LLM layer for triage: Natural language processing identifies urgency signals in patient messages (“severe headache + swelling” → preeclampsia risk)
  • Human escalation pathway: Urgent cases flagged for immediate nurse review, not autonomous LLM response
  • Evaluation boundary: Measure urgent-message detection, false escalation, missed urgency, nurse workload, and care-seeking separately from the reach of the underlying messaging service

Rationale for the hybrid approach:

The design uses language-model capabilities for message interpretation while retaining human review for urgent cases. This architecture limits autonomous action but does not guarantee that every model error will be caught.

Evidence boundary: The 2018 MomConnect reports documented national scale and implementation lessons but did not establish causal effects on maternal or child health outcomes (Barron et al., 2018). Later language-model integration requires its own evaluation and should not inherit outcome claims from the underlying messaging program.

Lessons for public health LLM deployment:

An SMS front end with an LLM backend is designed to support triage at population scale without requiring smartphone adoption. The same architecture may apply to outbreak communications, syndromic surveillance reporting, and community health worker support in LMICs, subject to its own evaluation.

DeepDR-LLM: Hybrid AI for Population Diabetes Management

A multimodal system combining image-based deep learning with language models demonstrates how LLMs can augment primary care capacity for chronic disease management in resource-limited settings, directly relevant to public health prevention programs.

System design for population health:

DeepDR-LLM integrates diabetic retinopathy screening (image AI) with personalized diabetes management recommendations (LLM) adapted to Chinese primary care settings. The system was trained on 371,763 real-world management recommendations from 267,730 participants (Li et al., Nature Medicine, 2024).

Prospective validation and separate reader study:

In a prospective study comparing patients under unassisted primary care physicians (n=397) versus PCP + DeepDR-LLM support (n=372):

  • Self-management: Patients with newly diagnosed diabetes showed significantly better self-management behaviors throughout follow-up (p<0.05)
  • Diabetic retinopathy referrals: Patients with referable DR were more likely to adhere to referrals (p<0.01)
  • Diagnostic accuracy: In a separate retrospective reader study, primary-care physician accuracy for identifying referable diabetic retinopathy increased from 81.0% unassisted to 92.3% with DeepDR-Transformer assistance (Li et al., 2024)

Public health significance:

Hybrid systems combining task-specific AI (image analysis) with general-purpose LLMs (clinical guidance) may offer more reliable population health support than LLMs alone, reducing hallucination risks while maintaining personalization capabilities for chronic disease management programs.

AfriMed-QA: Validating LLMs for Diverse Populations

The evaluation gap in public health AI:

Most medical AI benchmarks (USMLE, MedQA) are developed from Western medical education contexts, using disease patterns, treatment options, and healthcare infrastructures common in high-income countries. Public health systems deploying LLMs for surveillance, communications, or decision support need benchmarks reflecting local disease burdens, resource constraints, and cultural contexts.

AfriMed-QA: First pan-African medical AI benchmark:

AfriMed-QA is a large pan-African, multi-specialty medical question-answer dataset designed to evaluate LLM performance in contexts relevant to African healthcare (Nimo et al., 2025).

Dataset composition:

  • ~15,000 questions spanning 32 clinical specialties
  • Contributors: More than 60 medical schools across 16 African countries
  • Question types: Expert multiple-choice questions (4,000+), short-answer questions (1,200+), consumer health queries (10,000)
  • Recognition: Awarded Best Social Impact Paper at ACL 2025

Why this matters for public health:

When 30 different LLMs were evaluated using AfriMed-QA, performance patterns differed substantially from Western benchmarks. Models that excelled on USMLE showed weaker performance on Africa-specific questions, revealing gaps in knowledge about:

  • Endemic infectious diseases: Malaria, schistosomiasis, trypanosomiasis (neglected tropical diseases critical for public health surveillance)
  • Resource-adapted protocols: Treatment options available in LMIC settings, not only what is optimal in HICs
  • Traditional medicine interactions: Community health practices that affect public health program design
  • Local drug formularies: What is available for public health programs to recommend
  • Cultural and linguistic considerations: Critical for outbreak communications and health education

Public health application:

AfriMed-QA can supplement, but not replace, task-specific local validation. It is an English medical question-answering benchmark, not evidence that a system is safe or useful for surveillance, communication, or deployment in a specific jurisdiction.

Access for public health practitioners:

The dataset is publicly available at afrimedqa.com and through the GitHub repository, enabling health departments and researchers to evaluate and fine-tune LLMs for their specific population contexts before deployment in surveillance systems, health communication platforms, or decision support tools.

Environmental Justice and LLM Sustainability in Public Health

The hidden cost of computational intensity:

Training and deploying LLMs consume vast computational resources, with environmental impacts that disproportionately affect LMICs even when the technology is developed and deployed primarily in high-income countries.

Energy and emissions profile:

  • Training emissions: A single large model training run can produce substantial CO₂-equivalent emissions
  • Inference costs: While individual queries consume relatively little energy, cumulative daily use across public health applications (surveillance coding, outbreak communications, health education chatbots) scales with volume
  • Water consumption: Data centers require substantial water for cooling; water scarcity is more acute in many LMIC regions
  • Hardware lifecycle: Rare-earth mining for GPUs and electronic waste disposal create environmental burdens concentrated in resource-extraction regions

The public health equity dimension:

LMICs contribute minimally to AI development emissions but bear disproportionate climate impacts from environmental degradation and water scarcity. As public health systems in high-income countries adopt LLM-based surveillance tools, communications platforms, and decision support systems, the cumulative carbon footprint grows while benefits accrue primarily to well-resourced settings.

Climate-health nexus:

Public health practitioners understand the health impacts of climate change (heat-related illness, vector-borne disease expansion, food insecurity). LLM deployment in public health should be evaluated through a climate-health lens, weighing population health benefits against environmental costs, particularly for applications in climate-vulnerable regions.

Sustainable deployment strategies for public health:

  1. Edge deployment over cloud: Running LLMs locally on health department servers reduces data transfer energy costs and supports data sovereignty for sensitive surveillance data
  2. Model efficiency: Smaller, task-optimized models rather than general-purpose large models where appropriate (syndromic surveillance may not need GPT-4 scale)
  3. Renewable energy: Data centers powered by solar, wind, or hydroelectric rather than fossil fuels
  4. Shared infrastructure: Regional public health data centers serving multiple countries, reducing redundant computational capacity

Policy implication:

As LLMs are evaluated for public health applications, environmental sustainability should be an explicit criterion, alongside population health effectiveness and cost-effectiveness. The most sustainable public health AI solution may be the simplest one that achieves public health objectives, not the most sophisticated.

Global Governance for Public Health AI

WHO Global Initiative on AI for Health (GI-AI4H):

Launched in July 2023 by WHO, the International Telecommunication Union (ITU), and the World Intellectual Property Organization (WIPO), GI-AI4H provides an institutional framework for coordinating responsible AI development and deployment globally (WHO/ITU/WIPO, 2023).

Strategic focus areas for public health:

  1. Standards development: International standards for AI evaluation, ethics, clinical validation, and benchmarking applicable to public health surveillance and decision support systems
  2. Knowledge transfer: Facilitating data sharing, collaboration, and best practice dissemination among public health stakeholders worldwide
  3. Health system strengthening: Prioritizing low- and middle-income countries through a scaling program initially targeting 12–18 countries with relevant AI use cases

Public health applications:

GI-AI4H standards can guide public health departments deploying LLMs for surveillance coding (ICD-10, SNOMED CT automation), outbreak risk communication (multilingual health messaging), and health education (chatbot accuracy standards).

Lancet Global Health Commission on AI and HIV:

This Commission synthesizes evidence on AI’s economic and health impacts across different settings, with explicit focus on guiding responsible AI model development and creating actionable guidance for stakeholders in regulation and adoption. HIV surveillance, prevention, and treatment programs are early adopters of AI in public health, providing lessons for broader LLM deployment (Lancet Global Health, ongoing).

Gates Foundation AI equity initiatives:

In September 2026 the Gates Foundation announced plans to spend at least US$1 billion over two years on equitable AI, distributed roughly 40% to health care (diagnostics and decision support for frontline health workers, maternal and newborn care tools, and drug and vaccine discovery) and 10% to digital foundations such as datasets in languages that current tools do not cover. The announcement states that effective tools require data and expertise from the populations they serve, with countries and communities deciding how data is managed and protected (Gates Foundation, September 2026). It is a funding plan and reports no evaluation results or health outcomes.

WHO Global Strategy on Digital Health (2020–2027):

The Seventy-eighth World Health Assembly extended the Global Strategy on Digital Health from 2025 through 2027 in May 2025, with a follow-up framework for 2028-2033 under development (WHO, May 2025). Since its adoption, 129 countries have established national digital health strategies. The strategy covers national digital health infrastructure, interoperability standards, and health data governance, providing the overarching framework within which AI-specific initiatives (GI-AI4H, WHO ethics guidance) operate.

Implication for public health practitioners:

These frameworks provide actionable guidance for health departments deploying LLMs in global public health contexts. Health departments can use WHO standards, Lancet Commission recommendations, and philanthropic partnership opportunities to support responsible implementation.

Practical Guidance for LLM Deployment in Public Health Systems

Pre-deployment checklist for health departments:

Before deploying any LLM system in public health applications:

  1. Validate on public health tasks (surveillance coding accuracy, risk communication clarity, triage appropriateness), not just general medical knowledge
  2. Validate on context-specific populations (AfriMed-QA for Africa; similar datasets for Asia, Latin America where available)
  3. Assess infrastructure requirements (internet connectivity for cloud models, computational capacity for edge deployment, electricity reliability)
  4. Evaluate language support (does the LLM support local languages and dialects, or only English? Critical for health communications)
  5. Verify safety mechanisms (how does the system handle uncertainty, avoid hallucinations, escalate to public health professionals?)
  6. Establish oversight (who reviews LLM outputs before population-level communications? Who monitors surveillance coding accuracy?)
  7. Plan for sustainability (who maintains the system when external funding ends? What is the long-term cost structure for health department budget?)
  8. Address data sovereignty (where is surveillance data processed and stored? Does this comply with local regulations and public health confidentiality requirements?)
  9. Measure environmental impact (what are the energy and water requirements? Can renewable energy support deployment? Do public health benefits justify environmental costs?)

Red flags warranting rejection:

  • LLM vendor cannot demonstrate performance on public health tasks (surveillance, risk communication, triage)
  • System requires always-on internet connectivity in settings with unreliable access (fails during outbreaks when most needed)
  • No mechanism for public health professional oversight of LLM outputs before population-level dissemination
  • Deployment plan lacks sustainable financing beyond external grant period (common failure mode in public health pilots)
  • Surveillance or population health data will be processed on foreign servers without clear data protection agreements
  • Vendor dismisses environmental impact questions or lacks sustainability data

Green flags supporting adoption:

  • Prospective validation in deployment setting on public health tasks (not just clinical medicine benchmarks)
  • Offline or edge deployment capability for low-connectivity environments
  • SMS access for users with basic feature phones (as in the MomConnect architecture)
  • Human-in-the-loop design with clear escalation pathways to public health professionals
  • Open-weight model with local customization and fine-tuning potential for local disease patterns and languages
  • Integration with existing public health information systems (DHIS2, OpenMRS, national surveillance platforms)
  • Health department or ministry of health ownership with budget commitment (not donor-dependent pilot)
  • Explicit environmental sustainability assessment appropriate for climate-health context

The Path Forward: Co-Development for Public Health

The extractive model (what to avoid):

  1. HIC institution develops LLM on Western data and disease patterns
  2. Pilots system in LMIC public health department with external funding
  3. Publishes papers on “global health AI” without local authorship
  4. Funding ends, system abandoned, no local capacity remains
  5. Public health department returns to manual processes, wasted investment

The co-development model (what to pursue):

  1. Joint problem definition: LMIC and HIC public health partners identify priority use cases together (surveillance gaps, communication barriers, workforce shortages)
  2. Shared data governance: Training data includes LMIC disease patterns and public health contexts, with local ownership and benefit-sharing
  3. Capacity building from inception: Local public health researchers and informaticians co-lead development, not just deployment
  4. Prospective validation: Local public health validation before scale-up (surveillance accuracy, communication effectiveness, triage appropriateness)
  5. Sustainable financing: Health ministry integration and budget commitment, not donor dependency
  6. Knowledge transfer: Local teams can maintain, improve, and adapt systems independently

Public health practitioner role:

Public health professionals in high-income countries evaluating LLM vendors or research partnerships should demand evidence of co-development, equitable partnerships, and sustainable implementation rather than extractive “deploy and abandon” models. Public health practitioners in LMICs should advocate for local ownership, capacity building, and benefit-sharing rather than accepting passive recipient roles in technology transfer.


One Health: AI Across the Human-Animal-Environment Interface

The National One Health Framework to Address Zoonotic Diseases (NOHF-Zoonoses), released in January 2025 by CDC, USDA, and DOI, represents the first coordinated U.S. approach to diseases that spread between animals and humans. AI applications in One Health surveillance address threats that single-sector approaches miss.

Why One Health Matters for Public Health AI

Jones et al. found that 60.3% of 335 emerging infectious-disease events were zoonotic (Jones et al., 2008); WHO states that more than 60% of reported emerging infectious diseases originate in animals (WHO, May 2026). Recent examples:

Pathogen Animal Reservoir Human Impact
SARS-CoV-2 Bats (likely via intermediate host) Pandemic, 7+ million deaths
H5N1 Avian Influenza Poultry, wild birds, dairy cattle U.S. dairy cattle outbreak from 2024; sporadic human cases
Mpox Rodents Global outbreak, 2022–present
Ebola Bats Recurring outbreaks in West/Central Africa

Traditional surveillance operates in silos: human health agencies track human cases, veterinary agencies track animal disease, environmental agencies track wildlife. AI can integrate these data streams to detect threats earlier.

The NOHF-Zoonoses Framework (2025–2029)

The framework establishes seven goals, with AI implications across multiple domains:

Goal 5: Surveillance includes:

  • Enhanced monitoring systems for zoonotic diseases
  • Data interoperability across human, animal, and environmental sectors
  • Advanced pathogen detection technologies

Goal 6: Laboratory emphasizes:

  • Strengthened diagnostic capabilities
  • Genomic sequencing for pathogen characterization
  • Data sharing protocols across agencies

AI Applications in One Health

1. Spillover Risk Prediction

AI models can integrate:

  • Wildlife population data (migration patterns, population density)
  • Livestock management practices (factory farming density)
  • Land use changes (deforestation, agricultural expansion)
  • Climate data (temperature, precipitation affecting vector habitats)
  • Human encroachment patterns

Demonstrated: Retrospective models have identified risk factors for known spillover events. Theoretical: Prospective prediction of novel spillover events remains unvalidated.

2. Genomic Surveillance Integration

Combining genomic data from human and animal isolates improves outbreak understanding:

  • SARS-CoV-2 surveillance detected deer-to-human transmission through genomic analysis
  • H5N1 sequencing revealed adaptation patterns in dairy cattle
  • Nextstrain and GISAID platforms enable cross-species phylogenetic analysis

See AI in Genomic Surveillance and Pathogen Analysis for technical details on pathogen genomics.

3. Antimicrobial Resistance Tracking

Antimicrobial resistance surveillance must connect human health, animal production, food systems, and environmental sampling. Detecting the same resistance marker in more than one sector does not by itself establish cross-species transmission. Interpretation requires organism attribution, genomic context, exposure data, and appropriate epidemiologic comparison.

The AI in Genomic Surveillance and Pathogen Analysis chapter provides the canonical treatment of resistome analysis, wastewater AMR surveillance, genomic phenotype prediction, forecasting baselines, and AMRnet. One Health programs should use those methods to coordinate population-level surveillance rather than infer patient-level susceptibility or treatment.

Case Study: H5N1 in U.S. Dairy Cattle (2024-2025)

The detection of H5N1 avian influenza in U.S. dairy cattle in 2024 illustrated One Health gaps:

What happened:

  • Virus detected in dairy herds across multiple states
  • Genomic evidence showed sustained cow-to-cow transmission
  • Limited human cases among dairy workers
  • Questions arose about spillover timing and extent

AI-relevant lessons:

  1. Surveillance data across species was not integrated in real time
  2. Genomic data sharing between veterinary and public health agencies was delayed
  3. Predictive models for mammalian adaptation were not deployed operationally
  4. Worker health surveillance relied on voluntary reporting

For detailed analysis of H5N1 AI applications, see the Biosecurity Handbook.

Implementation Barriers

Data silos: Human health (HHS), animal health (USDA), wildlife (DOI), and environmental (EPA) data systems do not interoperate. The U.S. One Health Coordination Unit (launched January 2024) aims to address this, but technical integration remains incomplete.

Jurisdictional complexity: Federal agencies, state agencies, tribes, and international partners all hold relevant data. No single entity has authority to mandate integration.

Privacy asymmetry: Human health data faces HIPAA and 42 CFR Part 2 restrictions. Animal and environmental data generally do not. AI systems must navigate different data governance regimes.

Resource gaps: One Health surveillance requires expertise across disciplines (epidemiology, veterinary medicine, ecology, data science). Few jurisdictions have this capacity.

Key Resources

Key Takeaways

  1. AI amplifies inequity by default: Without intentional equity focus, AI widens health disparities by concentrating benefits in privileged populations.

  2. Design for constraints, not ideal conditions:

    • Offline-first: works without continuous connectivity
    • Low-power: runs on battery-powered devices
    • Robust to poor data: handles low-quality images, missing values, and limited labels
    • Culturally appropriate: uses local language, terminology, and cultural norms
  3. Success stories demonstrate feasibility: retinopathy screening (India), TB detection (Africa), malaria diagnosis (SE Asia) show AI can work in resource-limited settings when thoughtfully designed.

  4. Algorithmic fairness requires active work:

    • Diverse training data from multiple populations
    • Fairness-aware training with constraints
    • Regular auditing across demographic groups
    • Local fine-tuning for specific contexts
  5. Build sustainable local capacity:

    • Train local data scientists (awareness → literacy → application → development → research)
    • Invest in local infrastructure
    • Share code, models, and knowledge
    • Plan for long-term local ownership
  6. Data governance prevents exploitation:

    • Data sovereignty: the source retains control
    • Benefit sharing: co-authorship, IP sharing, and revenue sharing
    • Equitable partnerships: partners avoid data colonialism
    • Capacity building: knowledge is transferred rather than extracted
  7. Context-appropriateness matters more than sophistication: a simple SMS-based system with local ownership can outperform a sophisticated cloud system that requires continuous connectivity.

  8. Measure what matters: assess context-appropriateness, sustainability, equity, and local ownership alongside accuracy, performance, and deployment.

  9. Infrastructure is foundational: AI cannot compensate for missing electricity, internet access, or digital health systems.

  10. Global health AI should benefit those who need it most: AI that works only for the wealthy and connected fails this test.


Hands-On Exercise: Assess an AI Tool for Your Context

Objective: Evaluate whether an AI health tool is appropriate for a resource-limited setting.

Scenario: You are a public health official in a lower-middle-income country. An international NGO is offering to deploy an AI-powered disease surveillance system in your country. Assess whether this system is appropriate for your context.

Part 1: Context Assessment

Define your context:

my_context = {
 'country': 'Example Country',
 'income_level': 'Lower-middle',
 'infrastructure': {
  'internet_penetration': 0.45, # 45% population
  'electricity_reliability': 0.70, # Reliable 70% of time
  'mobile_phone_penetration': 0.80, # 80% population
  'ehr_penetration': 0.10, # 10% facilities have EHR
  'health_workers_per_10k': 15 # Below WHO recommendation of 44.5
 },
 'priority_health_issues': ['Malaria', 'TB', 'Maternal mortality', 'Malnutrition'],
 'languages': ['English', 'Local Language 1', 'Local Language 2'],
 'existing_surveillance': 'Paper-based reporting from facilities to district to national level'
}

Questions:

  1. What are your main infrastructure constraints?
  2. What are your priority health problems?
  3. What is your current surveillance system?

Part 2: AI Tool Assessment

The proposed AI tool:

proposed_tool = {
 'name': 'SmartSurveillance AI',
 'purpose': 'Real-time disease outbreak detection',
 'data_sources': [
  'Electronic health records',
  'Laboratory results',
  'Social media monitoring',
  'Weather data',
  'Google search trends'
 ],
 'requirements': {
  'internet': 'High-speed internet required',
  'hardware': 'Cloud-based (AWS), requires continuous internet',
  'data': 'Requires structured EHR data',
  'training': '2-week training for data analysts',
  'cost': '$50,000 setup + $20,000/year subscription',
  'support': 'Email support (24-48 hour response)'
 },
 'languages': ['English'],
 'development': 'Developed in USA, trained on US data',
 'evidence': 'Tested in USA, UK, Australia'
}

Assess appropriateness:

class ContextAppropriatenessChecker:
 """Check if AI tool is appropriate for context"""

 @staticmethod
 def check_requirements(context, tool):
  """Check if context meets tool requirements"""
  checks = {}

  # Infrastructure checks
  checks['internet'] = {
   'required': 'High-speed',
   'available': f"{context['infrastructure']['internet_penetration']:.0%} penetration",
   'appropriate': context['infrastructure']['internet_penetration'] > 0.80
  }

  checks['electricity'] = {
   'required': 'Continuous',
   'available': f"{context['infrastructure']['electricity_reliability']:.0%} reliable",
   'appropriate': context['infrastructure']['electricity_reliability'] > 0.95
  }

  checks['data_infrastructure'] = {
   'required': 'EHR with structured data',
   'available': f"{context['infrastructure']['ehr_penetration']:.0%} facilities with EHR",
   'appropriate': context['infrastructure']['ehr_penetration'] > 0.70
  }

  # Cost check (as % of health budget per capita)
  # Example: Low-middle income ~$100 per capita health spending
  annual_cost = tool['requirements']['cost'].split('+')[1].replace('$','').replace('/year subscription','').replace(',','').strip()
  checks['cost'] = {
   'required': f"${annual_cost}/year",
   'appropriate': 'Requires cost-benefit analysis',
   'note': 'Compare to alternative surveillance approaches'
  }

  # Language check
  checks['language'] = {
   'required': ', '.join(tool['languages']),
   'available': ', '.join(context['languages']),
   'appropriate': any(lang in tool['languages'] for lang in context['languages'])
  }

  return checks

 @staticmethod
 def recommend_alternatives(context, tool, checks):
  """Recommend modifications or alternatives"""
  recommendations = []

  if not checks['internet']['appropriate']:
   recommendations.append({
    'issue': 'Insufficient internet connectivity',
    'recommendation': 'Request offline-first version',
    'alternative': 'Use SMS-based reporting with simpler ML models'
   })

  if not checks['data_infrastructure']['appropriate']:
   recommendations.append({
    'issue': 'Insufficient EHR penetration',
    'recommendation': 'Start with paper-based data entry',
    'alternative': 'Use syndromic surveillance (symptoms only, no lab data)'
   })

  if not checks['language']['appropriate']:
   recommendations.append({
    'issue': 'Language mismatch',
    'recommendation': 'Request localization to [Local Languages]',
    'alternative': 'Develop local language version with local partner'
   })

  # Always recommend local validation
  recommendations.append({
   'issue': 'Tool not validated in local context',
   'recommendation': 'Require pilot study with local data',
   'alternative': 'Collaborate with local university to validate and adapt'
  })

  return recommendations

# Run assessment
checker = ContextAppropriatenessChecker()
checks = checker.check_requirements(my_context, proposed_tool)

print("CONTEXT-APPROPRIATENESS ASSESSMENT")
print("="*50)
for requirement, result in checks.items():
 status = "[OK]" if result.get('appropriate', False) else "[FAIL]"
 print(f"\n{status} {requirement.upper()}:")
 print(f" Required: {result['required']}")
 print(f" Available: {result.get('available', 'n/a')}")

# Get recommendations
recommendations = checker.recommend_alternatives(my_context, proposed_tool, checks)
print("\n\nRECOMMENDATIONS")
print("="*50)
for i, rec in enumerate(recommendations, 1):
 print(f"\n{i}. {rec['issue']}")
 print(f" Recommendation: {rec['recommendation']}")
 print(f" Alternative: {rec['alternative']}")

Your assessment:

  1. Is this tool appropriate for your context as-is?
  2. What modifications would make it more appropriate?
  3. What alternatives might be better suited to your context?

Part 3: Equity and Governance

Assess the partnership:

partnership_terms = {
 'data': {
  'data_storage': 'Cloud (AWS, USA servers)',
  'data_ownership': 'NGO retains ownership',
  'data_use': 'NGO can use for research and product improvement',
  'data_sharing': 'NGO can share with partners'
 },
 'capacity_building': {
  'training': '2-week online training',
  'ongoing_support': 'Email support only',
  'local_capacity': 'No plan for local AI capacity'
 },
 'intellectual_property': {
  'ownership': 'NGO owns all IP',
  'customization': 'NGO controls all customization',
  'code_access': 'No access to source code'
 },
 'costs': {
  'setup': '$50,000 (funded by NGO)',
  'subscription': '$20,000/year (funding for 3 years, then country pays)',
  'support': 'Included in subscription'
 },
 'evaluation': {
  'performance': 'NGO evaluates',
  'data': 'NGO publishes findings',
  'feedback': 'Country can provide feedback'
 }
}

# Assess governance equity
print("\nGOVERNANCE EQUITY ASSESSMENT")
print("="*50)

red_flags = []
green_flags = []

# Data control
if 'retains ownership' in partnership_terms['data']['data_ownership']:
 red_flags.append("[FAIL] Country does not control its own health data")
else:
 green_flags.append("[OK] Country retains control of health data")

# Capacity building
if 'No plan' in partnership_terms['capacity_building']['local_capacity']:
 red_flags.append("[FAIL] No sustainable local capacity building")
else:
 green_flags.append("[OK] Plan for sustainable local capacity")

# IP ownership
if 'NGO owns' in partnership_terms['intellectual_property']['ownership']:
 red_flags.append("[FAIL] Country has no IP rights to system built with its data")
else:
 green_flags.append("[OK] Joint IP ownership")

# Sustainability
if 'country pays' in partnership_terms['costs']['subscription']:
 red_flags.append("[FAIL] Dependency on external system with ongoing costs")
else:
 green_flags.append("[OK] Sustainable funding model")

print("\nRED FLAGS:")
for flag in red_flags:
 print(f" {flag}")

print("\nGREEN FLAGS:")
for flag in green_flags:
 print(f" {flag}")

print("\n\nRECOMMENDED NEGOTIATION POINTS:")
print("1. Data sovereignty: Country must retain ownership and control of health data")
print("2. Local storage: Data stored on local servers, not exported")
print("3. Capacity building: Commit to training local team to run system independently")
print("4. IP sharing: Joint ownership of any adaptations or innovations")
print("5. Open source: Access to source code for local customization")
print("6. Sustainability: Plan for local ownership within 3 years")
print("7. Evaluation: Joint evaluation with local researchers as co-authors")

Your assessment:

  1. What are the red flags in this partnership?
  2. What would you negotiate to make it more equitable?
  3. Would you accept this partnership? Why or why not?

Part 4: Alternative Approach

Design a more appropriate alternative:

Your task: Design a disease surveillance system that:

  • Works within your infrastructure constraints
  • Builds local capacity
  • Is sustainable
  • Maintains data sovereignty

Example approach:

alternative_system = {
 'name': 'LocalSurveillance',
 'design_principles': [
  'Offline-first',
  'Works with existing paper systems',
  'Low-cost',
  'Locally developed and owned',
  'Builds local capacity'
 ],
 'architecture': {
  'data_collection': 'SMS + simple mobile app (works offline)',
  'data_storage': 'Local servers (Ministry of Health)',
  'analysis': 'Simple ML models (run on laptop/local server)',
  'alerts': 'SMS alerts to health officials',
  'dashboard': 'Web dashboard (works on low bandwidth)'
 },
 'implementation': {
  'phase_1': '6 months - SMS pilot in 2 districts',
  'phase_2': '6 months - Expand to 10 districts, add simple ML',
  'phase_3': '12 months - National rollout'
 },
 'capacity_building': {
  'train_local_developers': '3-month intensive training',
  'train_health_workers': '1-day training on data entry',
  'establish_local_team': 'Hire 5 local data scientists',
  'partner_with_university': 'Joint project with local university'
 },
 'costs': {
  'setup': '$20,000 (servers, initial development)',
  'annual': '$10,000 (maintenance, hosting)',
  'capacity_building': '$50,000 (one-time training investment)',
  'total_5_year': '$120,000 vs $150,000 for proprietary system',
  'after_5_years': 'Fully locally owned and operated'
 },
 'governance': {
  'data_ownership': 'Ministry of Health',
  'code_ownership': 'Open source',
  'sustainability': 'Locally maintained',
  'scalability': 'Can be adapted for other countries'
 }
}

print("ALTERNATIVE SYSTEM: LocalSurveillance")
print("="*50)
print(f"\nDesign Principles:")
for principle in alternative_system['design_principles']:
 print(f" * {principle}")

print(f"\nCost Comparison (5 years):")
print(f" Proprietary system: $150,000")
print(f" LocalSurveillance: $120,000")
print(f" Savings: $30,000")
print(f"\n Plus: Builds local capacity, local ownership, sustainable")

print(f"\nCapacity Building:")
for activity, details in alternative_system['capacity_building'].items():
 print(f" • {activity}: {details}")

Your turn:

  1. Design an appropriate AI system for your context
  2. How would you implement it?
  3. How would you build local capacity?
  4. How much would it cost?
  5. How is it better than the proprietary alternative?

Check Your Understanding

Test your knowledge of global health AI equity and how to design AI systems that work for all populations. Each question addresses critical concepts from this chapter.

Question 1

A health NGO wants to deploy an AI diagnostic system in rural sub-Saharan Africa where electricity is available only 6 hours per day, internet connectivity is intermittent (2–3 hours daily), and there are no trained data scientists locally. Which deployment approach would be MOST sustainable and effective?

  1. Cloud-based AI requiring continuous internet, with remote technical support from the NGO’s headquarters in a high-income country
  2. Edge AI with offline-capable models on battery-powered tablets, local SQLite database, opportunistic syncing, and training local health workers to operate the system
  3. Paper-based system with periodic data entry and batch cloud processing when connectivity is available
  4. Wait to deploy until infrastructure improves (reliable electricity and internet) to ensure optimal system performance

Correct Answer: b) Edge AI with offline-capable models on battery-powered tablets, local SQLite database, opportunistic syncing, and training local health workers to operate the system

This question tests understanding of context-appropriate AI design for resource-limited settings, a central theme throughout the chapter’s discussion of the global digital divide and successful implementations.

The Chapter’s Context-Appropriate Design Principles:

Section “Context-Appropriate AI Design” establishes clear principles for resource-limited settings:

1. Offline-First Design: The chapter provides a complete OfflineAISystem implementation showing exactly this approach:

  • Local model inference (no internet required)
  • SQLite database for local storage
  • Opportunistic sync when connectivity available
  • Graceful failure handling

2. Low-Power Design: The chapter’s LowPowerOptimizer demonstrates:

  • Quantized models (smaller and more efficient; accuracy, latency, and power measured on the target hardware)
  • Battery-powered operation
  • Minimal power consumption

3. Human Capacity: The chapter emphasizes building local capacity rather than external dependence.

Why Option B is Correct:

Addresses all infrastructure constraints:

Electricity (6 hours/day):

  • Battery-powered tablets can operate during non-electricity hours
  • Devices charged during the 6-hour electricity window must run for the remaining 18 hours; battery life is confirmed on the target device and workload
  • Low-power quantized models extend battery life

Internet (intermittent 2–3 hours/day):

  • Edge AI runs entirely offline, no internet needed for diagnosis
  • Opportunistic sync uploads results when connectivity available
  • System continues functioning if sync fails (will retry later)

No local data scientists:

  • Training local health workers to operate (not develop) the system is feasible
  • The chapter’s retinopathy case study describes nurses operating the screening system after 1-day training
  • No ongoing technical expertise required for daily operation

Real-World Validation:

The case studies in Context-Appropriate AI Design, including diabetic retinopathy screening, TB screening from chest X-rays, and malaria microscopy, illustrate this design pattern. Each carries an evidence boundary: the cited studies evaluated algorithm performance, not deployment counts, costs, or outcomes at scale.

Why Other Options Fail:

Option (a), Cloud-based system:

This violates the chapter’s core principles and would fail in the described setting:

  1. Continuous internet requirement: With only 2–3 hours daily connectivity, the system is non-functional 21–22 hours per day. Patients arriving when internet is down cannot be diagnosed.

  2. Power dependency: Cloud systems require powered internet infrastructure (routers, modems). With 6 hours electricity, internet may only work during that window, reducing already limited 2–3 hour availability.

  3. External dependence: “Remote technical support from headquarters” creates unsustainable dependency. The chapter’s “Paradox of Need” callout describes this cycle: dependence on external solutions leads to tools that are not context-appropriate, then to poor outcomes and distrust of technology.

  4. Latency: Even when internet is available, cloud API calls in low-bandwidth settings add network delay to each diagnosis, while on-device inference does not depend on the connection.

  5. Cost: Cloud API fees accumulate with each use, while on-device inference avoids per-call fees once devices and models are in place.

Option (c), Paper + batch processing:

This is a half-measure that misses AI’s value proposition:

  1. Delays: Batch processing means results only available after next connectivity window, potentially 24–48 hour delays. For acute conditions, this defeats the purpose.

  2. Data entry bottleneck: Manual paper→digital transcription is labor-intensive and error-prone. Chapter emphasizes this challenge in the “Data Infrastructure Divide” section.

  3. Limited benefit: If the workflow remains paper-based, the AI adds little value compared with standard clinical protocols. The chapter describes edge AI’s value as real-time diagnostics without internet access.

  4. Scalability: Paper systems do not scale. The chapter’s case studies capture data digitally at the point of care.

Option (d), Wait for infrastructure:

This is explicitly rejected throughout the chapter:

The chapter’s “Paradox of Need” callout states: “Settings with the greatest potential AI impact often have the least capacity to develop, deploy, and maintain AI systems.” Waiting means:

  1. Opportunity cost: Patients who could benefit from AI diagnostics today continue suffering or dying while waiting for infrastructure that may never arrive (or take decades).

  2. No agency: Waiting for external infrastructure improvements means no local control over timeline.

  3. Contradicts chapter’s message: The entire chapter is about designing AI that works despite infrastructure limitations, not waiting for ideal conditions.

  4. Perpetuates inequity: The “wait for infrastructure” mentality ensures AI benefits only wealthy, connected populations, precisely the inequity the chapter aims to prevent.

The chapter’s key takeaways state: “Infrastructure is foundational - No amount of sophisticated AI can overcome lack of electricity, internet, or digital health systems.” But this means design for constraints, not wait for ideal infrastructure.

The Design for Constraints Philosophy:

The chapter’s key takeaway:

“Context-appropriateness beats sophistication” - Simple SMS-based system with local ownership often outperforms sophisticated cloud system requiring continuous connectivity.

Option B embodies this philosophy. Option A pursues sophistication at the expense of context-appropriateness. Options C and D do not fully use AI’s potential.

Implementation Path for Option B:

Phase 1: Setup (Weeks 1–4)

  • Procure battery-powered tablets
  • Load quantized diagnostic models (pre-trained, validated)
  • Set up local SQLite databases
  • Establish sync endpoint (when connectivity available)

Phase 2: Training (Week 5)

  • 1-week training for local health workers
  • Focus on: image capture, quality assessment, result interpretation
  • No advanced technical skills required

Phase 3: Deployment (Week 6+)

  • Begin seeing patients
  • Models run offline, store results locally
  • Periodic syncing uploads to central database for surveillance

Sustainability:

  • No ongoing internet costs
  • No ongoing technical support dependency (basic troubleshooting trainable)
  • Local ownership and operation

The Chapter’s Framework:

This aligns with the chapter’s design principles and assessment checklist:

  • Offline-first design
  • Low-power operation
  • Local capacity building
  • Sustainability planning
  • Context-appropriate technology

For practitioners:

The chapter’s “Paradox of Need” explains why settings with the greatest potential AI impact often have the least capacity. Breaking this cycle requires:

  1. Designing for constraints (not ideal conditions)
  2. Building local capacity (not external dependency)
  3. Prioritizing sustainability (not short-term pilots)

Option B achieves all three. The chapter’s case studies illustrate it, the chapter’s code shows it is technically feasible, and local ownership with minimal ongoing costs makes it sustainable.

The global health AI equity challenge is primarily one of appropriate design for context. Option B represents context-appropriate AI; the alternatives do not.

Question 2

An AI sepsis prediction model trained primarily on data from US and European hospitals is being considered for deployment in a low-income country. Initial testing reveals 91% accuracy on US patients but only 78% accuracy on the local population. What is the MOST likely primary cause of this performance disparity, and what is the appropriate response?

  1. The local population has genetic differences requiring a completely separate model from scratch
  2. The model suffers from dataset shift: training data does not represent local patient characteristics (disease prevalence, comorbidities, healthcare practices), requiring diverse training data and possibly local fine-tuning
  3. The local healthcare workers are less skilled at data entry, creating noisy input data
  4. The 78% accuracy is actually acceptable given resource constraints; deploy as-is since some AI is better than no AI

Correct Answer: b) The model suffers from dataset shift: training data does not represent local patient characteristics (disease prevalence, comorbidities, healthcare practices), requiring diverse training data and possibly local fine-tuning

This question tests understanding of algorithmic fairness, the importance of diverse training data, and how to address performance disparities across populations, key themes in the chapter’s “Algorithmic Fairness Across Populations” section.

The Chapter’s Evidence:

Performance Disparity Example (from chapter):

The chapter provides a nearly identical scenario in the FairnessAuditor example:

Overall Accuracy: 87.3%
--- Performance by COUNTRY ---
[OK] USA: 91.2% (disparity: +3.9%)
[WARNING] Kenya: 78.5% (disparity: -8.8%)
[WARNING] India: 80.1% (disparity: -7.2%)

[WARNING] Large performance disparity detected (>10%)

This is exactly the scenario in the question: high-income country model (91%) vs. LMIC performance (78%), with a 13-point disparity.

Root Cause: Dataset Shift

The chapter explicitly addresses this in “Strategies to Improve Fairness”:

Problem: “Models trained only on high-income country data perform poorly elsewhere.”

Why this happens:

1. Different disease prevalence:

  • High-income countries: More chronic diseases (diabetes, heart disease)
  • LMICs: More infectious diseases (TB, malaria, HIV) as comorbidities
  • Sepsis presentation differs with underlying conditions

2. Different patient populations:

  • Age distributions differ (LMICs have younger populations)
  • Nutritional status affects immune response and sepsis progression
  • Genetic diversity not captured in US/European datasets

3. Different healthcare practices:

  • US/Europe: Early ICU admission, aggressive interventions
  • LMICs: Later presentation (patients seek care later), fewer ICU beds
  • Different baseline vital signs cutoffs may apply

4. Different data characteristics:

  • US/Europe: Complete EHR data, frequent lab tests
  • LMICs: Sparse data, paper records, missing values common
  • Features available for prediction differ

5. Measurement differences:

  • Equipment calibration variations
  • Different lab reference ranges
  • Environmental factors (altitude affects oxygen saturation, temperature norms vary)

The Solution (from chapter):

The chapter provides three specific strategies:

Strategy 1: Diverse Training Data (Section “Diverse Training Data”):

The DiverseDatasetBuilder class shows:

  • Assess dataset diversity across dimensions (country, income level, ethnicity)
  • Balance dataset to ensure fair representation
  • Create stratified splits preserving diversity

The chapter emphasizes: “Include diverse training data from multiple populations.”

Strategy 2: Fairness-Aware Training (Section “Fairness-Aware Training”):

The FairML class demonstrates:

  • Training with fairness constraints (demographic parity, equalized odds)
  • Ensures model performs equitably across populations
  • Uses Fairlearn library for constrained optimization

Strategy 3: Local Fine-Tuning (Section “Local Fine-Tuning”):

The LocalFineTuner class shows:

  • Start with global model (retains general knowledge)
  • Fine-tune on local data (adapts to local context)
  • Transfer learning approach

Why this is correct:

The 13-point accuracy gap (91% vs. 78%) indicates the model learned patterns specific to US/European populations that do not generalize. This is dataset shift, the classic machine learning problem when training and deployment distributions differ.

Why Other Options Are Wrong:

Option (a), Genetic differences requiring separate model:

This is scientifically incorrect and potentially harmful:

  1. Overstates genetic differences: While genetic variation exists, population genetic differences are typically small and continuous, not categorical. Sepsis is primarily driven by infection and immune response, not population genetics.

  2. Ignores environmental/social factors: Healthcare access, disease prevalence, and treatment practices differ across populations and are not captured by a genetics framing. Option B captures these factors; option A does not.

  3. Inefficient: Starting from scratch discards valuable learned patterns (sepsis presentation, organ dysfunction progression). Transfer learning (option B’s fine-tuning) is more data-efficient.

  4. Data requirements: Training from scratch requires large labeled datasets. The chapter emphasizes LMICs often lack this data volume. Fine-tuning needs far less local data.

  5. Perpetuates bias: Treating populations as fundamentally different can reinforce biological essentialism and excuse algorithmic bias rather than addressing its root causes (training data limitations).

Option (c), Data entry quality:

This victim-blames local healthcare workers and misdiagnoses the problem:

  1. Assumption unfounded: The question provides no evidence of data quality issues. This option assumes without justification that LMIC healthcare workers are less competent.

  2. Misses root cause: Even with perfect data entry, a model trained on US patterns will not generalize to different disease prevalence, patient populations, and healthcare contexts.

  3. Unsupported by the chapter: The chapter’s case studies describe local health workers, such as nurses in the retinopathy program, operating AI systems. The chapter emphasizes capacity building, not capability deficits.

  4. Technical flaw: Robustness to data noise is empirical. The scenario does not provide evidence that data-entry noise explains the performance difference, so the cause must be investigated rather than assumed.

If data quality were the issue, the solution would be data validation and cleaning, not what the chapter recommends (diverse training data, fairness-aware training, local fine-tuning).

Option (d), Deploy despite poor performance:

This is ethically and practically unacceptable:

  1. Violates equity principle: The chapter’s core message is AI should work for all populations, not just the privileged. Accepting lower performance for LMICs perpetuates health inequities.

  2. Patient safety: 78% accuracy means 22% error rate. For sepsis (high mortality, time-sensitive), errors cost lives. “Some AI is better than no AI” is false when AI provides incorrect guidance.

  3. Erodes trust: Deploying underperforming AI damages trust in technology and healthcare system. The chapter’s “Paradox of Need” warns poor outcomes lead to distrust, reducing future technology adoption.

  4. Violates responsible evaluation: WHO ethics guidance supports evaluating the intended use and affected populations, but it does not prescribe a universal accuracy or disparity threshold.

  5. Requires a justified decision threshold: Fairness criteria should be prespecified, clinically or operationally justified, and interpreted with uncertainty rather than applying a universal 10% rule.

The “acceptable given resource constraints” reasoning is precisely the inequity the chapter argues against.

The Appropriate Response (from Chapter):

Step 1: Fairness Audit

auditor = FairnessAuditor()
results = auditor.audit_model_fairness(model, local_test_data, ['country'])

Step 2: Root Cause Analysis

  • Examine where model fails (which patient subgroups, which features)
  • Identify dataset shift characteristics
  • Quantify disparity magnitude

Step 3: Mitigation

  • Collect local data: The chapter’s fine-tuning example uses 500 local cases; the number needed depends on the task and must be confirmed by validation
  • Fine-tune model: Transfer learning retains general knowledge while adapting to local context
  • Retrain with diverse data: Include local data in global model training for future versions
  • Adjust thresholds: Post-processing fairness methods can equalize performance across populations

Step 4: Validation

  • Test fine-tuned model on held-out local data
  • Confirm the performance gap falls below a prespecified, justified threshold
  • Validate with local clinicians before deployment

Real-World Precedent:

The chapter’s Case Study 1 (Diabetic Retinopathy Screening) and Case Study 2 (TB Screening) both involved local adaptation:

  • Models developed with diverse international data
  • Fine-tuned for specific deployment contexts
  • Validated locally before rollout
  • Result: Performance comparable to expert human interpretation

The Chapter’s Framework for Fairness:

From the key takeaways: “Algorithmic fairness requires active work:

  • Diverse training data from multiple populations
  • Fairness-aware training with constraints
  • Regular auditing across demographic groups
  • Local fine-tuning for specific contexts”

Option B embodies this framework. Options A, C, and D do not.

For practitioners:

Performance disparities across populations are a warning sign of algorithmic unfairness, not an inevitability. The chapter provides the technical tools (fairness auditing, diverse datasets, fairness-aware training, local fine-tuning) to address these disparities.

The global health AI equity imperative requires rejecting the “good enough for poor countries” mentality. AI should work equitably for all populations, and the chapter shows how to achieve this.

Question 3

A research team from a high-income country wants to collect health data from multiple hospitals in a low-income country to train an AI model. They propose collecting de-identified data, training the model at their university, publishing in high-impact journals, and potentially commercializing the technology. How should this collaboration be structured to avoid data colonialism and ensure equity?

  1. Proceed as proposed, de-identification protects privacy and publication advances science for everyone’s benefit
  2. Establish a partnership with data sovereignty (local institution retains data control), co-authorship, IP sharing, capacity building (training local researchers), and benefit sharing arrangements
  3. Pay a one-time fee to the hospitals for data access to compensate them for their contribution
  4. Have local researchers sign consent forms acknowledging the high-income institution’s ownership of resulting IP

Correct Answer: b) Establish a partnership with data sovereignty (local institution retains data control), co-authorship, IP sharing, capacity building (training local researchers), and benefit sharing arrangements

This question tests understanding of equitable data governance, avoiding data colonialism, and building genuine partnerships, critical themes in the “Data Governance in Global Health” and “Building Local AI Capacity” sections.

The Chapter’s Data Governance Framework:

The “Data Governance in Global Health” section sets out principles for equitable data governance:

1. Data Sovereignty: The source institution retains access control, data use is limited to agreed purposes, and the framework prefers local storage and processing with minimal cross-border transfer.

2. Benefit Sharing: The chapter’s governance framework outlines specific mechanisms:

  • Authorship: Local partners as co-authors on all publications
  • Intellectual property: Joint ownership of innovations, joint patents, preferential licensing to the source country
  • Revenue sharing: Royalties from commercial applications
  • Capacity building: Training, infrastructure investment, knowledge transfer
  • Data return: Analysis results returned to the source community

3. Equitable Partnerships: The chapter contrasts exploitative vs. equitable models:

Extractive (Data Colonialism):

  • External researchers collect data
  • Analysis happens externally
  • Publications list external authors only
  • IP owned by external institution
  • No benefit to data source

Equitable:

  • Local partners involved from design stage
  • Shared governance
  • Co-authorship
  • IP sharing
  • Capacity building
  • Long-term commitment

Why Option B is Correct:

Option B implements ALL of the chapter’s recommended principles:

Data Sovereignty:

  • “Local institution retains data control” ensures data stays under local governance
  • Can use federated learning (covered in Emerging Technologies) to train collaboratively without data leaving the country
  • Local IRB oversight and approval required
  • Locals decide what research questions are priorities

Co-Authorship:

  • Recognizes local contribution to research
  • Ensures local researchers gain publication track record
  • Builds local academic capacity
  • The chapter’s framework lists co-authorship on all publications under benefit sharing

IP Sharing:

  • Local institution has ownership stake in resulting technology
  • Ensures commercialization benefits local populations
  • Can negotiate licensing terms favorable to low-income country access
  • The chapter’s framework lists joint patents and preferential licensing to the source country

Capacity Building:

  • “Training local researchers” breaks the dependency cycle
  • The chapter’s capacity building section describes a training progression:
    • Awareness → Literacy → Application → Development → Research
  • Creates sustainable local AI capability
  • Aligns with the chapter’s emphasis on “Build sustainable local capacity”

Benefit Sharing:

  • Ensures local population benefits from their data contribution
  • Can include revenue sharing from commercialization
  • Addresses the chapter’s concern about “value extraction without benefit sharing”

Real-World Validation:

The H3Africa (Human Heredity and Health in Africa) initiative was set up to build genomics research capacity led by African investigators (H3Africa Consortium, 2014, Science). The partnership model recommended here includes:

  • African scientists as co-PIs
  • Data governance by African institutions
  • Capacity building (training, infrastructure)
  • Benefit sharing agreements

Why Other Options Are Wrong:

Option (a), Proceed as proposed (extractive model):

This is textbook data colonialism that the chapter explicitly warns against:

Problems:

  1. No data sovereignty: Data collected and removed to high-income country. Local institution loses control over how their population’s data is used.

  2. No recognition: Publications listing only high-income researchers ignores local contribution. This perpetuates global health research inequities.

  3. No benefit sharing: Technology commercialized abroad, profits accrue to high-income institution. Local population whose data enabled the technology receives no benefit.

  4. No capacity building: No knowledge transfer to local researchers. Perpetuates dependence and “brain drain” (local researchers must go abroad to do advanced work).

  5. Violates ethics: The WHO AI ethics guidance cited in the chapter includes inclusiveness and equity among its principles; an arrangement in which only the high-income institution benefits fails that standard.

  6. De-identification insufficient: De-identification protects privacy but does not address exploitation. Data colonialism can occur even with de-identified data.

The chapter’s data colonialism callout describes this pattern: value extraction without benefit sharing, including collaborations in which LMIC partners collect data but have no say in how it is used.

Option A is precisely this extractive model.

Option (c), One-time fee:

This treats data as a commodity for purchase rather than a partnership:

Problems:

  1. Transactional, not collaborative: One-time payment does not create ongoing partnership. The chapter’s framework calls for a plan for local capacity to continue the work.

  2. No capacity building: Money does not build local AI capability. The chapter’s framework prioritizes knowledge transfer, not financial transactions.

  3. Undervalues data: Health data enables potentially valuable technology (diagnostics, drugs). One-time fee is typically far less than commercialization value. This is exploitation.

  4. No data sovereignty: Payment does not ensure local control over data use. External researchers still take data and use however they want.

  5. Perpetuates inequity: Wealthy institutions can afford to buy data from poor countries, concentrating AI capabilities in high-income settings. This widens the AI divide the chapter aims to close.

  6. Ethical concerns: Paying hospitals for patient data raises questions about patient consent and whether hospitals should profit from patient information.

The chapter does not present a one-time payment as an equitable arrangement. It emphasizes partnership, not purchase.

Option (d), Consent to external IP ownership:

This is exploitative with a veneer of consent:

Problems:

  1. Coercive: Local researchers may feel pressured to sign to access collaboration opportunities. This is not genuine consent in unequal power dynamics.

  2. Violates benefit sharing: Explicitly gives all IP to external institution, ensuring locals receive no commercialization benefits.

  3. No true partnership: Treating locals as data providers who must “consent” to external ownership is hierarchical, not collaborative.

  4. Perpetuates inequity: Ensures technology and profits flow to already-wealthy institutions. The chapter’s equity framework rejects this.

  5. Unethical: The chapter’s framework requires benefit sharing through co-authorship, joint IP, and revenue sharing. Consenting to unfair distribution does not make it fair.

The chapter defines data colonialism as extraction of data from LMICs for the benefit of high-income countries or companies, with limited benefit to the source populations.

Option D is an extractive agreement with legal cover.

The Chapter’s Recommended Approach:

Partnership Checklist:

  • Joint problem definition: What health challenges do local partners prioritize?
  • Shared governance: Decision-making authority for both parties
  • Data sovereignty: Data stays under local control
  • Co-authorship: Local researchers as co-authors, not just acknowledged
  • IP sharing: Shared ownership of resulting technology
  • Capacity building: Training, infrastructure investment, knowledge transfer
  • Benefit sharing: Revenue sharing if commercialized
  • Long-term commitment: Ongoing relationship, not one-off project
  • Local deployment: Ensure resulting technology is accessible to data-providing community

Implementation Example:

Phase 1: Partnership Formation

  • Joint research proposal with local institution as co-PI
  • Data governance agreement (data stays local or federated learning)
  • MOU specifying co-authorship, IP sharing, benefit sharing
  • IRB approval from both institutions

Phase 2: Capacity Building

  • Train local researchers in AI/ML methods
  • Provide access to computational resources
  • Joint supervision of graduate students

Phase 3: Research Execution

  • Collaborative model development (federated learning if data cannot leave country)
  • Local researchers involved in all analysis stages
  • Regular joint meetings and knowledge exchange

Phase 4: Dissemination

  • Co-authored publications (local researchers as co-first/co-senior authors)
  • Joint conference presentations
  • IP jointly owned by both institutions

Phase 5: Deployment and Benefit Sharing

  • Technology deployed first in data-providing country
  • If commercialized: revenue sharing agreement (e.g., 50/50 split)
  • Licensing terms ensure affordable access in LMICs
  • Continued capacity building and support

The Chapter’s Broader Context:

This aligns with the chapter’s key takeaways: “Data governance prevents exploitation:

  • Data sovereignty - Source retains control
  • Benefit sharing - Co-authorship, IP sharing, revenue sharing
  • Equitable partnerships - Avoid data colonialism
  • Capacity building - Knowledge transfer, not extraction”

For practitioners:

International health data collaborations must be genuinely equitable, not extractive. The chapter provides a clear framework distinguishing the two.

Key principles:

  • If only the high-income partner benefits → Exploitation
  • If both partners share governance, credit, IP, and benefits → Equity

Option B embodies equity; the alternatives are varying degrees of exploitation.

The global health AI divide will only be bridged through equitable partnerships that build local capacity and ensure fair benefit sharing. Data colonialism, even when legal and technically sophisticated, perpetuates the inequities the chapter aims to address.

Question 4

A mobile health app using AI is being deployed in a multilingual low-income country with diverse ethnic groups, varying health literacy levels, and strong cultural norms around family decision-making (especially for women’s health). What is the MOST important design consideration to ensure the app is culturally appropriate and effective?

  1. Translate the English interface to the dominant local language and deploy uniformly across the country
  2. Design with cultural localization: support multiple languages, use local disease terminology, respect cultural norms (family involvement, traditional medicine integration), and adjust health communication to local literacy levels
  3. Use only visual icons and images to bypass language barriers entirely
  4. Deploy in English since it’s widely understood by educated populations who are most likely to use mobile apps

Correct Answer: b) Design with cultural localization: support multiple languages, use local disease terminology, respect cultural norms (family involvement, traditional medicine integration), and adjust health communication to local literacy levels

This question tests understanding of cultural localization, linguistic diversity, and human-centered design for global health AI, key themes in the “Culturally and Linguistically Appropriate” subsection of “Context-Appropriate AI Design”.

The Chapter’s Localization Framework:

The chapter provides a complete LocalizedHealthAI implementation demonstrating exactly this approach.

The “Localization Checklist” (from chapter):

  • Language: Support local languages, not just English
  • Terminology: Use local disease names and terms
  • Cultural norms: Respect gender roles, family decision-making
  • Traditional medicine: Acknowledge and integrate where appropriate
  • Religious considerations: Respect dietary restrictions, prayer times
  • Health literacy: Adjust communication complexity to education level

Why Option B is Correct:

Option B implements ALL elements of the chapter’s localization checklist:

1. Multiple Language Support:

The chapter’s example shows:

  • Different regions use different languages (Swahili in East Africa, French in West Africa, etc.)
  • Multilingual models (XLM-RoBERTa, mBERT, IndicBERT)
  • Translation to/from English for processing, with local language interface

Example from chapter:

system = LocalizedHealthAI(language='sw', region='east-africa')
# User reports symptoms in Swahili
symptoms_swahili = "Nina homa kali na kichwa kinaniuma"
# System processes and responds in Swahili

Why this matters: Language barriers limit healthcare access, and English-only systems exclude non-English speakers.

2. Local Disease Terminology:

Examples of local terms:

  • “Malaria” → “Homa ya malaria” (Swahili; “homa” alone means fever, as in the symptom example above), “Paludisme” (French), “Malária” (Portuguese)
  • “Tuberculosis” → “Kifua kikuu” (Swahili), “TB” (Global)

Why this matters: Patients describe symptoms using local terms. AI must understand these to function effectively.

3. Cultural Norms (Family Decision-Making):

The chapter’s cultural guidelines explicitly address this:

cultural_guidelines = {
 'south-asia': {
  'gender_sensitivity': 'high', # May need male family member involvement
 }
}

The generated recommendation includes: “Please discuss this with your family before making treatment decisions.”

Why this matters: In many cultures, health decisions (especially for women) involve family members. An app that ignores this is culturally inappropriate and ineffective. Users will not follow recommendations that violate cultural norms.

4. Traditional Medicine Integration:

The chapter’s example shows:

if cultural_guidance['traditional_medicine'] == 'integrate':
 recommendation += "This recommendation can complement traditional treatments. Consult both your healthcare provider and traditional healer."

Why this matters: Many populations use both traditional and modern medicine. Acknowledging this builds trust and adherence. Dismissing traditional medicine alienates users.

5. Health Literacy Adjustment:

The checklist includes: “Adjust communication complexity to education level.”

Why this matters: Technical medical language excludes low-literacy populations. The app must communicate in accessible terms.

Real-World Validation:

The chapter’s retinopathy case study generates action plans in Hindi and English. The cited case-study papers evaluated algorithm performance, not user acceptance, so the accessibility and acceptance of a localized interface must be measured in the deployed workflow.

Why Other Options Are Wrong:

Option (a), Single dominant language:

This assumes linguistic homogeneity that does not exist:

Problems:

  1. Ignores multilingualism: Many LMICs, including India, Nigeria, and Kenya, are highly multilingual. A “dominant language” may not be spoken by much of the population.

  2. Excludes minorities: Minority language speakers (often marginalized populations) are excluded. This perpetuates health inequities.

  3. Misses cultural nuances: Translation alone does not address cultural norms, disease terminology, traditional medicine integration, or literacy levels. The chapter shows these are equally important.

  4. Uniform deployment fails: The chapter emphasizes context-appropriate design. Different regions have different needs; uniform deployment ignores this.

Option (c), Icons/images only:

This oversimplifies and has serious limitations:

Problems:

  1. Limited expressiveness: Medical concepts (symptoms, diagnoses, recommendations) are complex. Icons cannot convey nuanced information like “take medication with food” or “seek care if symptoms worsen.”

  2. Cultural interpretation varies: Symbols have different meanings across cultures. A thumbs-up or checkmark may not be universally understood as positive. Color symbolism varies (white is mourning in some cultures, purity in others).

  3. Patronizing: Assuming users cannot handle text (with appropriate literacy-level adjustment) is condescending and disempowering.

  4. Medical accuracy: Icons are imprecise. “Fever” might be represented by a thermometer, but does not convey severity. Misinterpretation can lead to clinical errors.

  5. Ignores cultural norms: Icons do not address family decision-making norms, traditional medicine, religious considerations. These require text explanations.

The chapter never suggests icon-only approaches. Its localization approach uses text in local languages, with images as supplements.

Option (d), English for educated users:

This is elitist and excludes most of the target population:

Problems:

  1. Excludes majority: Even in countries where English is an official language, fluency is often limited to urban, educated elites. Rural and low-income populations (who need healthcare AI most) typically speak local languages.

  2. Contradicts equity mission: The chapter emphasizes AI should serve those most in need, not just the privileged. English-only systems serve those with education access, perpetuating inequities.

  3. Reduces effectiveness: Even for English speakers, health communication is more effective in first language. Stress and illness reduce ability to process second language.

  4. Cultural inappropriateness: English explanations may not align with local cultural norms, disease concepts, or traditional medicine.

  5. Violates accessibility principles: The chapter’s framework calls for AI that works for all populations. English-only fails this standard.

  6. Context mismatch: The chapter’s case studies target rural settings in India, sub-Saharan Africa, and Southeast Asia, where many intended users have limited English.

The Chapter’s Broader Framework:

This question aligns with multiple chapter themes:

1. Context-Appropriate Design: “Effective AI in LMICs requires designing for constraints, not assuming ideal conditions.”

English-only, single-language, or icon-only approaches assume ideal conditions (linguistic homogeneity or universal icon comprehension). Option B designs for real-world constraints (multilingual, multicultural populations).

2. Equity: “Global health AI should benefit those who need it most - AI that works only for the wealthy and connected fails this test.”

English-only and single dominant language approaches work for urban, educated populations. Option B works for everyone, including marginalized language minorities.

3. Local Ownership: Cultural localization requires local input: what terminology do locals use? What cultural norms matter? This builds local ownership and sustainability.

Implementation Considerations:

Full Localization (Option B):

Languages:

  • Identify languages spoken in deployment area (survey or census data)
  • Prioritize by speaker population
  • Use multilingual models (XLM-RoBERTa) or translation services

Terminology:

  • Work with local health workers to map local disease terms
  • Build terminology dictionaries
  • Validate with community input

Cultural Norms:

  • Consult local cultural experts and community leaders
  • Identify relevant norms (gender, family, religion, traditional medicine)
  • Incorporate into system logic and recommendations

Literacy:

  • Assess target population literacy levels
  • Adjust language complexity (Flesch-Kincaid grade level)
  • Use audio for very low literacy
  • Supplement text with images (not replace)

Testing:

  • Usability testing with diverse user groups (languages, cultures, literacy levels)
  • Iterate based on feedback
  • Validate cultural appropriateness

The Chapter’s Key Message:

From the key takeaways: “Context-appropriateness beats sophistication - Simple SMS-based system with local ownership often outperforms sophisticated cloud system requiring continuous connectivity.”

Applied to this question: Culturally localized system with appropriate language/cultural support outperforms technically sophisticated English-only system.

For practitioners:

Global health AI cannot be “one size fits all.” The chapter demonstrates that effective, equitable AI requires deep cultural localization:

  • Multiple languages (not just English or dominant language)
  • Local terminology (not just translation)
  • Cultural respect (family norms, traditional medicine, religion)
  • Appropriate literacy level (accessible to target population)

Option B embodies this complete approach. The alternatives take shortcuts that reduce accessibility and effectiveness.

The global health AI divide is partly technical, but also cultural and linguistic. Option B addresses all three dimensions; the alternatives address at most one.

Question 5

A health ministry in a lower-middle-income country wants to build local AI capacity rather than depending on external consultants indefinitely. According to the chapter’s capacity building framework, what is the MOST effective long-term strategy?

  1. Send a few promising individuals abroad for PhD training, expecting them to return and lead AI development
  2. Implement a complete multi-year program with staged training (awareness → literacy → application → development → research), infrastructure investment, partnerships with universities, retention strategies, and knowledge sharing networks
  3. Hire expensive international consultants to run AI projects, with local staff observing to learn on the job
  4. Purchase commercial AI software with vendor support rather than building in-house capacity

Correct Answer: b) Implement a complete multi-year program with staged training (awareness → literacy → application → development → research), infrastructure investment, partnerships with universities, retention strategies, and knowledge sharing networks

This question tests understanding of sustainable capacity building for AI in resource-limited settings, a critical theme in the chapter’s “Building Local AI Capacity” section and central to breaking the “Paradox of Need” cycle.

The Chapter’s Capacity Building Framework:

The “Building Local AI Capacity” section sets out a staged training progression:

The Training Progression (from chapter):

  1. Awareness (1-day workshop): Understanding AI capabilities, limitations, and applications
  2. Literacy (1-week course): Core AI concepts and evaluation of AI tools and vendors
  3. Application (3-month part-time bootcamp): Applying machine learning to local health problems
  4. Development (6-month full-time program): Building custom models, fine-tuning, and integration
  5. Research (2-year fellowship): Conducting original AI research

Why Option B is Correct:

Option B implements ALL elements of the chapter’s complete capacity building framework:

1. Staged Training Progression:

The chapter explicitly outlines the awareness → literacy → application → development → research pathway.

Why this matters:

  • Sustainable: Builds capability layer by layer
  • Retention-friendly: Provides career progression locally
  • Scalable: Each stage creates teachers for the next cohort
  • Context-appropriate: Focuses initially on application (deploying AI) before research (creating new methods)

Rushing to research (option A) skips critical foundational stages.

2. Infrastructure Investment:

The chapter emphasizes infrastructure as foundational:

  • “Infrastructure is foundational - No amount of sophisticated AI can overcome lack of electricity, internet, or digital health systems.”

What’s needed:

  • Computational resources (cloud accounts or local GPUs)
  • Data infrastructure (EHRs, data quality systems)
  • Collaboration tools
  • Internet bandwidth for training/access to resources

Why this matters: Trained people without infrastructure cannot deploy AI. The chapter shows capacity = people + infrastructure + partnerships.

3. Partnerships with Universities:

The chapter’s capacity framework assesses academic, industry, and government partnerships. Its illustrative five-year plan targets 20 academic partnerships and three university AI programs, and its research level is a fellowship with an international university partner.

Why this matters:

  • Access to expertise: University partners provide training and mentorship
  • Sustainability: Local universities can continue training after initial program
  • Research capacity: Enables local research, not just application
  • Legitimacy: Academic credentials and publications build credibility

4. Retention Strategies:

Retention addresses the “brain drain” challenge: trained individuals may leave for better opportunities elsewhere.

Mitigation strategies:

  • Competitive salaries and career advancement
  • Interesting, impactful work
  • Recognition (publications, presentations)
  • Community and collaboration
  • Clear career pathways

Why this matters: Training without retention wastes investment. Option A (send abroad for PhD) has high brain drain risk.

5. Knowledge Sharing Networks:

The chapter’s key takeaways call for sharing code, models, and knowledge. Mechanisms include:

  • Peer-to-peer learning networks
  • Communities of practice
  • Open source contributions

Why this matters: Isolated individuals struggle. Networks provide support, problem-solving, and continuous learning.

Real-World Validation:

Elements of durable capacity-building programs:

  • Multi-year program
  • Staged training (workshops → degree programs → independent research)
  • Infrastructure investment (genomics facilities)
  • University partnerships
  • Knowledge sharing (annual conferences)

Why Other Options Fail:

Option (a), Send individuals abroad for PhD:

This is the classic approach associated with “brain drain”:

Problems:

  1. High brain drain risk: Trainees may not return after PhDs abroad when they find better salaries, resources, and career opportunities in high-income countries.

    International training can contribute to brain drain when local roles, infrastructure, mentorship, and career pathways are weak. The extent varies by country, discipline, destination, and cohort.

  2. Isolated individuals: Sending “a few” creates isolated experts without peer support. The chapter emphasizes community and networks.

  3. No infrastructure: Returnees find no computational resources, data, or institutional support to apply their training. Frustration leads to departure.

  4. Does not scale: Training a few individuals (even if retained) does not build national capacity. The chapter’s staged approach trains cohorts who then train others.

  5. Mismatch: PhD training abroad focuses on research (stage 5) before application/development (stages 3–4). This does not meet immediate needs (deploying AI for local health challenges).

  6. Resource intensive: International doctoral training requires sustained funding and does not by itself build an institutional team.

  7. Long horizon: Doctoral training addresses a different capability level from near-term applied workforce development.

Brain drain is the central risk: trained individuals may leave for opportunities in high-income countries.

Option (b) addresses this through retention strategies. Option (a) exacerbates it.

Option (c), Observe international consultants:

This creates permanent dependency, not capacity:

Problems:

  1. Passive learning: Observation without hands-on practice does not build competency. The chapter’s staged approach requires active doing at each level.

  2. No knowledge transfer: Consultants often do not share methodological details (proprietary knowledge). Locals learn what to do, not why or how to do it themselves.

  3. Expensive: Multi-year reliance on international consultants accumulates fees that could instead fund training local staff.

  4. Unsustainable: When consultants leave, projects often collapse. No local capacity remains.

  5. Wrong incentives: Consultants benefit from dependency (more contracts). They lack incentive to transfer knowledge that makes them unnecessary.

  6. Cultural mismatch: External consultants may not understand local context, leading to context-inappropriate solutions (the chapter’s major theme).

The chapter’s “Paradox of Need” callout describes the cycle: limited resources → limited AI capacity → dependence on external solutions → not context-appropriate → poor outcomes.

Option C perpetuates this dependency cycle. Option B breaks it.

Option (d), Purchase commercial software:

This is outsourcing, not capacity building:

Problems:

  1. No capacity built: Purchasing software does not create local expertise in AI development, adaptation, or deployment.

  2. Vendor lock-in: The chapter’s technology selection guidance lists vendor lock-in as a risk to avoid.

  3. Limited customization: Commercial software is generic, not adapted to local diseases, populations, or workflows. The chapter emphasizes context-appropriateness requires customization.

  4. Ongoing costs: Licensing fees, support contracts, updates. Sustainable capacity requires local ownership, not perpetual payments.

  5. No research capability: Purchasing software does not build research capacity to advance the field or address local challenges.

  6. Black box: Commercial systems are often proprietary black boxes. Locals cannot inspect, validate, or adapt algorithms.

  7. Dependency: If vendor discontinues product or changes pricing, locals are stranded.

The chapter’s framework prioritizes: “Build sustainable local capacity” and “Plan for long-term local ownership.”

Option D achieves neither. It is appropriate for specific tools but not a capacity building strategy.

The Chapter’s Complete Framework:

Capacity Building Components (adapted from the chapter):

1. Training Pipeline:

  • Awareness workshops (health workers)
  • Literacy courses (public health practitioners)
  • Application bootcamps (data analysts)
  • Development programs (engineers)
  • Research training (scientists)

2. Infrastructure:

  • Cloud computing accounts
  • GPU access (local or cloud)
  • Data infrastructure (EHRs, quality systems)
  • Collaboration tools

3. Partnerships:

  • Local universities (curriculum, degrees)
  • International universities (mentorship, exchange)
  • Industry partners (internships, applied projects)
  • Government support (funding, policy)

4. Retention:

  • Competitive salaries
  • Career pathways
  • Impactful work opportunities
  • Recognition mechanisms
  • Community building

5. Knowledge Sharing:

  • Communities of practice
  • Regular workshops/conferences
  • Open source contributions
  • Internal knowledge bases

6. Sustainability:

  • Train trainers (stage N teaches stage N-1)
  • Institutional commitment
  • Long-term funding
  • Local leadership

Implementation Timeline:

Year 1:

  • Awareness training for health ministry (100 people)
  • Literacy training for data analysts (20 people)
  • Infrastructure setup (cloud accounts, data systems)
  • University partnerships established

Year 2:

  • Application training for first cohort (ready to deploy AI)
  • Literacy training for second cohort
  • First AI deployments (using trained cohort)
  • Development training for advanced learners

Year 3:

  • Development training for first cohort (building custom models)
  • Application training for second cohort
  • Literacy training for third cohort
  • Research training for most advanced

Years 4–5:

  • Research capacity online (publishing, innovating)
  • First cohort trains new cohorts (sustainability)
  • Local centers of excellence established
  • Reduced external dependence

The Chapter’s Key Message:

From the key takeaways: “Build sustainable local capacity:

  • Train local data scientists (awareness → literacy → application → development → research)
  • Invest in local infrastructure
  • Share code, models, and knowledge
  • Plan for long-term local ownership”

Option B embodies this complete vision. Options A, C, and D are partial measures that do not achieve sustainable local capacity.

For practitioners:

The chapter’s message is clear: Capacity building requires multi-year investment. Quick fixes (international consultants, commercial software, sending a few individuals abroad) do not create sustainable local capability.

Effective capacity building requires:

  • Multi-year commitment (not one-off workshops)
  • Staged progression (do not skip foundational stages)
  • Infrastructure investment (people need tools)
  • Retention focus (training without retention wastes resources)
  • Local leadership (locals design and lead programs)

The global health AI divide will not be bridged by sending LMIC researchers abroad or hiring consultants. It requires sustained investment in complete local capacity building.

Option B represents this sustainable approach. It is harder and slower than the alternatives, but it is the only path to genuine, lasting local AI capability.

Question 6

A foundation wants to fund AI for global health projects in LMICs. When evaluating proposals, which project characteristic would be the STRONGEST indicator of likely long-term success and sustainable impact according to the chapter’s framework?

  1. The project uses the most advanced, state-of-the-art AI techniques (deep learning, transformers, etc.)
  2. The project is led by prestigious universities from high-income countries with strong track records
  3. The project has local leadership, addresses a locally prioritized health problem, includes capacity building and knowledge transfer, and has a sustainability plan for local ownership after external funding ends
  4. The project promises to screen the largest number of patients in the shortest time

Correct Answer: c) The project has local leadership, addresses a locally prioritized health problem, includes capacity building and knowledge transfer, and has a sustainability plan for local ownership after external funding ends

This question tests understanding of what makes AI projects succeed sustainably in global health contexts, synthesizing themes from throughout the chapter about equity, context-appropriateness, local ownership, and sustainability.

The Chapter’s Success Framework:

The chapter provides multiple case studies and explicit criteria for successful, equitable global health AI. The analysis below covers what Option C gets right and why the alternatives fail.

Why Option C Indicates Success:

1. Local Leadership:

The chapter emphasizes throughout that local leadership is critical for success:

From Data Governance in Global Health: In the co-development model, local researchers and informaticians co-lead development from inception.

From the case studies:

  • Retinopathy screening (India): “Developed with Aravind Eye Hospitals (local expertise)”

Why this matters:

  • Context understanding: Local leaders understand local health priorities, cultural context, and implementation realities
  • Sustainability: Locals have long-term commitment; external partners may leave
  • Trust: Communities trust local-led initiatives more than external impositions
  • Capacity building: Local leadership develops local capability

Absence of local leadership is a red flag for:

  • Potential data colonialism
  • Context-inappropriate design
  • Unsustainable external dependency
  • Limited local buy-in

2. Locally-Prioritized Health Problem:

The chapter warns against external priorities imposed on LMICs:

The chapter’s co-development model starts with joint problem definition: LMIC and HIC public health partners identify priority use cases together.

Why this matters:

  • Relevance: Addresses real needs, not what external funders think is important
  • Adoption: Healthcare workers prioritize solutions to their pressing problems
  • Impact: Solves problems locals face daily
  • Respect: Recognizes local expertise in identifying their own priorities

External-imposed priorities often lead to:

  • Solutions for problems that are not priorities
  • Low adoption (not addressing urgent needs)
  • Abandoned after funding ends (no local investment)

3. Capacity Building and Knowledge Transfer:

The chapter makes capacity building central to sustainable impact:

From the key takeaways: “Build sustainable local capacity:

  • Train local data scientists
  • Invest in local infrastructure
  • Share code, models, and knowledge
  • Plan for long-term local ownership”

Why this matters:

  • Sustainability: Locals can maintain, adapt, and improve after external partners leave
  • Scalability: Trained locals can lead new projects
  • Equity: Builds local capability, not dependency
  • Innovation: Empowered locals can address other health challenges

Absence of capacity building indicates:

  • Extractive model (use local data, provide no local benefit)
  • Dependency (requires perpetual external support)
  • Unsustainability (collapses when funding ends)

4. Sustainability Plan for Local Ownership:

The chapter emphasizes thinking beyond the funding period:

Sustainability questions (adapted from the chapter’s assessment checklist):

  • Who maintains the system after project ends?
  • How is it funded long-term?
  • Are local institutions committed to continuation?
  • Is infrastructure sustainable (electricity, internet, hardware)?

Why this matters:

  • Long-term impact: Many pilots succeed then disappear when funding ends
  • Resource stewardship: Donor funds should not create temporary solutions
  • Realistic planning: Forces consideration of long-term costs and feasibility

The chapter’s mTRAC case study was designed for national deployment from the start rather than as a pilot, and its co-development guidance warns against systems abandoned when funding ends.

The Chapter’s Case Study Success Factors:

The chapter’s first three case studies illustrate Option C’s characteristics:

Case Study 1: Portable Eye Exam System (India)

  • Local leadership: Developed with Aravind Eye Hospitals
  • Local priority: Blindness prevention in diabetic population
  • Capacity building: Nurses trained to operate
  • Sustainability: Integrated into existing primary care workflow

Case Study 2: Chest X-Ray AI (Sub-Saharan Africa)

  • Local priority: TB remains a major cause of illness and death
  • Capacity building: AI preliminary reading with remote radiologist review of flagged cases
  • Sustainability: Portable equipment, offline operation

Case Study 3: Malaria Diagnosis (Southeast Asia)

  • Local priority: Malaria is a major health burden, and trained microscopists are scarce in rural areas
  • Capacity building: Real-time image-quality feedback for smartphone operators
  • Sustainability: Smartphone-based microscopy

Why Other Options Do Not Indicate Success:

Option (a), Most advanced AI techniques:

This confuses technical sophistication with impact:

Problems:

  1. Context-appropriateness matters more: The chapter’s key message: “Context-appropriateness beats sophistication - Simple SMS-based system with local ownership often outperforms sophisticated cloud system.”

  2. Advanced ≠ deployable: The newest models often require:

    • Large computational resources (expensive, unavailable in LMICs)
    • Extensive training data (may not exist for local populations)
    • Specialized expertise to maintain (brain drain risk)
  3. Overfitting to research: The newest techniques are often research prototypes, not production-ready systems. The chapter’s case studies use established methods.

  4. Wrong incentives: Focus on technical novelty incentivizes publishable research over practical impact. The chapter distinguishes research contributions from implementation success.

  5. Missing key factors: Does not address local leadership, capacity building, sustainability, all more important for long-term success than technical sophistication.

The chapter’s case studies use established techniques (CNNs for image classification, basic ML) and depend on the other factors in Option C.

Option (b), Prestigious high-income country universities:

This is the traditional extractive model the chapter warns against:

Problems:

  1. Not necessarily equitable: Prestige does not ensure equitable partnership. The chapter warns about data colonialism from high-income institutions.

  2. May lack local context understanding: External researchers, even prestigious ones, often do not understand local health systems, cultural context, or implementation realities.

  3. Brain drain risk: Prestigious external universities may attract local talent away (fellowships, positions).

  4. Does not ensure sustainability: “Strong track record” in high-income settings does not predict success in resource-limited settings with different constraints.

  5. Missing critical factors: Prestige does not indicate local leadership, capacity building, or sustainability planning.

The chapter’s partnership framework emphasizes equity over prestige: Shared governance, co-authorship, IP sharing, capacity building. A prestigious external university CAN be a good partner, but only if the partnership is equitable (local co-leadership, capacity building, sustainability planning, Option C’s elements).

Option (d), Screen largest number of patients fastest:

This prioritizes scale over sustainability:

Problems:

  1. Vanity metrics: Large numbers look good for reports but do not ensure quality, sustainability, or long-term impact.

  2. Pilot fatigue: Many LMICs have experienced large-scale pilots that disappear when funding ends, leaving no lasting impact. The chapter’s mTRAC case study was designed for national deployment from the start rather than as a pilot.

  3. Does not ensure quality: Screening many patients poorly is worse than screening fewer patients well.

  4. Unsustainable: Massive short-term campaigns often are not sustainable after funding ends.

  5. Missing key factors: Says nothing about local leadership, capacity building, or sustainability, all critical for long-term success.

The chapter’s key takeaways state: “Measure what matters:

  • Not just performance, but also sustainability
  • Not just deployment, but also equity and local ownership”

Option D measures deployment scale, not sustainability or equity.

The Foundation’s Evaluation Rubric (Illustrative Weights):

To evaluate proposals, assess:

1. Partnership Equity (30%):

  • Local co-leadership (not just “collaboration”)
  • Shared governance
  • Co-authorship and IP sharing
  • Benefit sharing plans

2. Context-Appropriateness (25%):

  • Addresses locally prioritized problem
  • Designed for local infrastructure constraints
  • Culturally appropriate
  • Aligns with local health system workflows

3. Capacity Building (25%):

  • Specific training plans (not just “workshops”)
  • Staged progression (awareness → research)
  • Knowledge transfer mechanisms
  • Retention strategies

4. Sustainability (20%):

  • Long-term funding plan
  • Local ownership structure
  • Maintenance and support plan
  • Scalability pathway

Option C addresses all four dimensions. Options A, B, and D address at most one.

Red Flags (Reject These Proposals):

Based on the chapter’s framework:

  • External leadership only (no local co-PIs)
  • Data extraction without benefit sharing
  • No capacity building component
  • No sustainability plan
  • Addresses external-imposed priorities (not local)
  • Requires infrastructure unavailable locally
  • Perpetuates dependency on external partners
  • Short timeline (6–12 months) with no continuation plan

Green Flags (Fund These Proposals):

Based on the chapter’s framework:

  • Local co-leadership from design stage
  • Addresses locally identified priority
  • Context-appropriate design (offline, low-power, culturally adapted)
  • Complete capacity building plan
  • Sustainability plan with local ownership
  • Equitable benefit sharing
  • Realistic timeline (multi-year commitment)
  • Partnership with local institutions
  • Knowledge sharing and open source

Option C exhibits all the green flags.

The Chapter’s Broader Message:

From the key takeaways: “Global health AI should benefit those who need it most - AI that works only for the wealthy and connected fails this test.”

Implications for funding decisions:

Do not fund:

  • Technically impressive but context-inappropriate projects
  • Extractive research from prestigious institutions without local partnership
  • Large-scale deployments without sustainability plans

Do fund:

  • Locally led, equitable partnerships
  • Context-appropriate solutions to local priorities
  • Complete capacity building
  • Sustainable, locally owned implementations

For practitioners (funders):

The chapter provides clear guidance for funders wanting to support equitable global health AI:

Evaluation criteria should prioritize:

  1. Equity: Local leadership, shared governance, benefit sharing
  2. Relevance: Locally prioritized problems, context-appropriate design
  3. Sustainability: Capacity building, local ownership, long-term planning
  4. Impact: Addresses real health needs, scalable, sustainable

Not:

  1. Technical sophistication
  2. Prestige of external partners
  3. Scale of deployment
  4. Publishability in high-impact journals

Option C embodies the first set of criteria, the ones that predict long-term success and sustainable impact. The alternatives prioritize factors that do not ensure sustainable, equitable impact.

The global health AI divide will not be bridged by funding the most technically sophisticated projects from the most prestigious institutions. It requires funding equitable, locally led, sustainable partnerships that build local capacity.

Option C represents this approach.

Why can a health AI system fail when transferred to a lower-resource setting?

The target population, disease prevalence, language, clinical workflow, equipment, data definitions, referral capacity, connectivity, power, staffing, and maintenance environment may differ from the development setting. These are not secondary implementation details. They determine whether inputs are available, whether the model remains calibrated, and whether an output can lead to care. Transfer therefore requires local problem definition, external and local validation, workflow testing, and monitoring rather than simple software installation.

What does the digital divide mean for global health AI?

The divide includes more than internet access. It includes reliable electricity, affordable devices and data, compatible information systems, local-language interfaces, technical staff, procurement capacity, and the authority to maintain or replace a system. A cloud-dependent product may exclude facilities with intermittent connectivity, while a smartphone-only workflow may exclude workers or patients who use basic phones. Design should begin with measured constraints at the intended sites.

What is data colonialism in health AI?

Data colonialism describes extractive arrangements in which data and analytic value move away from source communities while decision authority, authorship, infrastructure, and benefits remain elsewhere. A fair partnership defines local governance, permitted uses, access, benefit sharing, authorship, capacity building, return of results, and exit conditions before data collection. National control alone is not sufficient if affected communities and local institutions lack meaningful participation.

How should AI be designed for resource-constrained settings?

Use the simplest technology that can solve the defined problem. Offline-first operation, low-power hardware, graceful failure, local language support, repairability, transparent rules, and compatibility with existing reporting systems may matter more than marginal benchmark gains. The system should preserve a manual fallback and should be maintainable with locally available skills and financing. A pilot should measure service delivery and equity outcomes, not only algorithm accuracy.

How can bias widen global health inequity?

A model can underperform when the training data omit relevant populations, devices, disease patterns, or care pathways. Even equal model performance can produce unequal benefit when confirmatory testing, referral, treatment, or connectivity is unavailable. Equity evaluation should therefore examine access, data quality, error rates, action completion, and outcomes across relevant groups and locations. Mitigation may require redesigning the service pathway rather than only changing the model.

What makes a global health AI example credible?

The evidence should name the exact product or model version, setting, population, comparator, reference standard, workflow, and endpoint. Deployment counts, screening costs, workload effects, and patient outcomes should not be transferred from a vendor announcement or a different study. A technically successful pilot becomes a credible implementation case only when the supporting source and the claimed result match and the limits are explicit.

Discussion Questions

  1. Digital divide: How can AI deployment avoid widening health inequities between and within countries? What role should high-income countries play?

  2. Context appropriateness: Should simpler, locally developed solutions take priority over sophisticated but externally dependent ones? What trade-offs are acceptable?

  3. Capacity building: What is the best way to build sustainable AI capacity in LMICs? Short-term training? Long-term fellowships? Technology transfer? Building from scratch?

  4. Data governance: How can LMIC data be protected from exploitation by high-income countries or corporations? What does equitable data partnership look like?

  5. Algorithmic fairness: Whose responsibility is it to ensure AI works for all populations? Developers? Regulators? International organizations?

  6. Innovation models: Should LMICs focus on adapting existing AI tools or developing their own? What are the pros and cons of each approach?

  7. Sustainable funding: How can LMICs sustainably fund AI infrastructure and capacity when facing competing health priorities? Should international donors support AI?

  8. Evaluation standards: Should AI in LMICs meet the same evaluation standards as AI in high-income countries, or should “good enough” be acceptable when the alternative is no access to specialists?


Further Resources

Books and Reports

Global health and equity:

  • WHO (2021). “Ethics and Governance of AI for Health” - Framework for responsible AI in global health
  • Abebe et al. (2021). “Roles for Computing in Social Change” - Critical perspectives on technology and development
  • Madianou (2019). “Technocolonialism: Digital Innovation and Data Practices in the Humanitarian Response to Refugee Crises”

AI in resource-limited settings:

  • Schwalbe & Wahl (2020). “AI and the Future of Global Health”

Key Papers

Infrastructure and access:

  • Wahl et al. (2018). “Artificial intelligence (AI) and global health: how can AI contribute to health in resource-poor settings?” BMJ Global Health
  • Shaw et al. (2023). “Artificial intelligence and health equity in global health.” The Lancet Global Health

Algorithmic fairness:

Successful implementations:

Data governance:

  • Hummel et al. (2021). “Data sovereignty in Africa.” Information & Communication Technologies in Africa
  • Principles for Digital Development: https://digitalprinciples.org

Tools and Frameworks

Fairness tools:

  • Fairlearn (Microsoft): Fairness assessment and mitigation - https://fairlearn.org
  • AI Fairness 360 (IBM): Full suite of fairness metrics and algorithms - https://github.com/Trusted-AI/AIF360
  • What-If Tool (Google): Visual fairness investigation - https://pair-code.github.io/what-if-tool

Offline-first tools:

  • TensorFlow Lite: On-device ML - https://www.tensorflow.org/lite
  • ML Kit: Mobile ML SDK - https://developers.google.com/ml-kit
  • ONNX Runtime: Cross-platform inference - https://onnxruntime.ai

Population health mapping:

  • Google Population Dynamics Foundation Model (PDFM): AI model predicting local health and demographic patterns in areas lacking comprehensive data. Combines satellite imagery, search trends, and geographic data through graph neural networks. Freely available on GitHub with a one-minute Colab notebook for resource-limited teams with unreliable connectivity. A 2026 preprint tested it on cholera in the DRC and dengue in Mexico; see Forecasting for what the gains were and where they disappeared.

Open health datasets (global):

  • Global Health Data Exchange: http://ghdx.healthdata.org
  • WHO Global Health Observatory: https://www.who.int/data/gho
  • Digital Health Atlas: https://digitalhealthatlas.org

Training Programs

Capacity building:

  • Data Science Africa: Annual workshop + year-round training - http://www.datascienceafrica.org
  • AI4D Africa: Fellowships and training - https://ai4d.ai
  • DeepLearning.AI: Free online courses (available globally) - https://www.deeplearning.ai
  • Fast.ai: Practical deep learning for coders - https://www.fast.ai

Global health AI:

  • AI for Global Health (Coursera): Overview course
  • Digital Health & AI (WHO): Online training modules

Organizations and Networks

Advocacy and research:

  • AI4D Network: African AI research network - https://ai4d.ai
  • Global Partnership on AI (GPAI): International AI governance - https://gpai.ai
  • Research ICT Africa: African ICT policy research - https://researchictafrica.net

Implementation partners:

  • Digital Square (PATH): Digital health in LMICs - https://digitalsquare.org
  • Médecins Sans Frontières: AI in humanitarian settings - https://www.msf.org

Key Resources for Practitioners


Looking Ahead

AI Policy and Governance in Healthcare covers:

  • Policy frameworks for AI in public health
  • Regulatory approaches across countries
  • Governance structures for health AI
  • Accountability mechanisms
  • International cooperation on health AI standards

The Public Health AI Handbook is free to read and cite, with no advertising. If this chapter informed your work, you can support the handbook.