Global Health AI Equity and Local Capacity

Population fairness, local workforce capacity, and employment implications of global health AI programs. The material is maintained separately so each operational question has a stable, focused reference.

Learning Objectives

• Identify the evidence and controls relevant to this decision area
• Distinguish technical performance from operational and population impact
• Apply the included framework without extending claims beyond the cited evidence

Chapter Summary (TL;DR)

Use explicit targets, populations, thresholds, and decision consequences. Require external evidence and local monitoring where deployment can affect people or programs. Preserve uncertainty and document limits.

Introduction

This focused reference is part of the broader Global Health AI Equity and Local Capacity overview. It preserves the detailed methods, examples, and exercises while reducing page size and improving direct navigation.

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 AI - Trained on light-skinned populations, 3x more errors on dark-skinned patients (Sjoding et al., 2020, NEJM)

2. Dermatology AI - Trained primarily on light skin, 30% lower accuracy on dark skin tones (Daneshjou et al., 2022, Science Advances)

3. Clinical risk scores - Often include race as a variable, leading to systematic under-treatment of Black patients (Obermeyer et al., 2019)

4. Diagnostic imaging - Models trained on high-quality Western imaging equipment perform poorly on lower-quality equipment in LMICs (Gichoya et al., 2022, Lancet Digital Health)

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:

=== 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%)
[WARNING] 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: Most AI health expertise is concentrated in high-income countries: - 90% of AI researchers are in North America, Europe, China - 95% of AI companies are in high-income countries - <1% of scientific publications on AI in health come from LMICs

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: - Kenya: Predicted HIV testing yield to optimize mobile testing locations - Uganda: Early warning system for disease outbreaks - India: Maternal health risk prediction for targeted interventions

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 - $30K-100K for African AI researchers - Compute credits - Access to Google Cloud for researchers - Workshops - AI training workshops across Africa - Networking - Connect African AI researchers

Outcomes (2019-2023): - 50+ research projects funded - 500+ researchers trained - 20+ datasets created - 15+ AI tools deployed in health, agriculture, education

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: - Trained 100+ students in AI/ML - Published 50+ papers - Deployed 5 AI tools in production - Inspired similar labs in Kenya, Ghana, Nigeria

---

Workforce and Employment Implications

AI’s Impact on Healthcare Employment

The adoption of AI to automate healthcare processes carries labor implications that disproportionately affect LMICs. 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, widening income inequality is projected as 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:

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.

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.

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. Research from aviation and other high-risk industries demonstrates that 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 will 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

---