Model Governance and Accountability: How Mathematical Models Should Be Reviewed, Monitored, Documented, and Used Responsibly

Last Updated June 14, 2026

Model governance and accountability examines how mathematical models should be documented, reviewed, approved, monitored, revised, and retired when they influence consequential decisions. A model is not only an equation, script, dashboard, or simulation. Once it informs action, it becomes part of an institutional decision process.

Models can clarify evidence, test assumptions, compare scenarios, estimate uncertainty, and support planning. They can also mislead when ownership, validation, use limits, monitoring, and decision responsibility are weak. The danger is not only that a model may be wrong. The danger is that a model may be trusted beyond its evidence, used beyond its intended domain, or treated as a substitute for judgment.

Responsible model governance keeps models useful without allowing them to become unchallengeable authorities. It makes purpose, assumptions, data, uncertainty, validation, review, approval, monitoring, and accountability visible.

Governance does not weaken modeling. It strengthens it. A governed model can be questioned, reproduced, updated, challenged, and constrained. An ungovorned model may appear efficient, but it can quietly accumulate risk.

Why Model Governance Matters

Model governance matters because models often influence decisions before their assumptions, limits, and consequences are fully understood. A model may begin as an analytical tool, then become a dashboard, policy reference, operational workflow, funding justification, risk ranking, or automated recommendation.

As model use expands, model risk expands. The model may be technically sound for one purpose but inappropriate for another. It may rely on outdated data. It may produce fragile outputs under changed conditions. It may embed value judgments inside technical choices. It may be interpreted as more certain than it is.

Governance makes model use inspectable. It allows institutions to ask not only whether a model works, but whether it should be used for a specific decision, under specific conditions, with specific limits.

Back to top ↑

What Model Governance Means

Model governance is the structured process for managing models across their lifecycle. It includes policies, roles, documentation, validation standards, review procedures, monitoring, escalation, and accountability mechanisms.

Governance is not merely compliance paperwork. It is the discipline that connects modeling to responsible use. It answers who built the model, why it exists, what evidence supports it, where it can be used, what uncertainty remains, who approved it, how it is monitored, and when it must change.

Governance gives a model an institutional memory. It prevents the model from becoming detached from its origin, purpose, evidence, and limits.

Back to top ↑

Accountability Is Not the Same as Accuracy

A model can be accurate in one setting and still be unaccountable. Accuracy concerns whether model outputs match evidence or expected behavior. Accountability concerns whether people and institutions can explain, justify, challenge, revise, and take responsibility for model use.

This distinction matters because a technically accurate model can still be harmful if it is used for the wrong decision, applied outside its domain, communicated poorly, or insulated from challenge.

Governance expands the question from “Is the model accurate?” to “Is the model responsibly built, reviewed, used, monitored, and governed?”

Back to top ↑

The Model Lifecycle

Models have lifecycles. They are conceived, designed, implemented, validated, approved, deployed, monitored, revised, and eventually retired. Governance should cover the entire lifecycle, not only the moment of initial approval.

A model lifecycle approach prevents one-time validation from becoming permanent permission.

Back to top ↑

Model Ownership and Decision Ownership

Model ownership and decision ownership should be separate but connected. A model owner is responsible for the model’s construction, documentation, validation, monitoring, and maintenance. A decision owner is responsible for how model outputs are used in action.

This distinction matters because models advise; people and institutions decide. A model owner should not assume that a valid model justifies any decision. A decision owner should not hide behind model output as if the model made the decision independently.

The model may generate evidence, but accountability attaches to the people and institutions that decide how evidence is used.

Back to top ↑

Documentation, Provenance, and Audit Trails

Documentation is the memory of a model. Provenance records where model ingredients came from. Audit trails show what changed, who reviewed it, and why a decision was made. Without these records, model governance becomes guesswork.

Documentation should cover data, assumptions, equations, parameters, code, dependencies, validation results, uncertainty, limitations, approval status, and monitoring requirements.

A model that cannot be documented cannot be responsibly governed. A model that cannot be audited should not be trusted for consequential use.

Back to top ↑

Validation, Review, and Approval

Validation asks whether a model is fit for its intended use. It is not a universal stamp of truth. A model can be valid for one purpose, one population, one time period, one geography, or one decision context, while being invalid elsewhere.

Approval should therefore be conditional. It should define the model’s approved domain, evidence base, uncertainty, use limits, monitoring requirements, and review schedule.

Validation should be proportional to stakes. Exploratory models require transparency and caution. High-stakes models require stronger evidence, independent review, monitoring, and accountability.

Back to top ↑

Use Limits and Approved Domains

Use limits define where a model may and may not be used. They are essential because models are often reused beyond their original purpose. A model built for explanation may be used for prediction. A model built for one setting may be applied elsewhere. A model built for aggregate analysis may be used on individuals.

Use limits are not signs of weakness. They are signs that the model’s evidence and responsibility have been taken seriously.

Back to top ↑

Monitoring, Drift, and Model Decay

Models decay when the world changes, data pipelines shift, behavior adapts, measurement changes, institutions alter processes, or the model is used in new ways. A model that was once useful can become unreliable.

Monitoring is the process of checking whether the model remains fit for use. It should examine performance, drift, data quality, assumption validity, user behavior, incidents, and changing context.

Monitoring turns governance into an ongoing practice. Without monitoring, approval becomes a one-time ritual rather than a continuing responsibility.

Back to top ↑

Incident Review, Revision, and Retirement

Model governance must include incident review. When a model fails, causes harm, produces unexpected outputs, is misused, or becomes unreliable, the institution needs a process for investigation and correction.

Revision is not a sign of failure. It is part of responsible modeling. Retirement is also necessary when a model can no longer be justified.

A mature governance process can say “revise,” “pause,” or “retire” when evidence requires it.

Back to top ↑

Governance in Public and Institutional Systems

Models used in public and institutional systems require special care because they can affect rights, resources, safety, services, trust, and legitimacy. Public models often involve contested values, unequal impacts, incomplete evidence, and decisions that affect people who did not choose to be modeled.

The more consequential the use, the stronger the governance must be.

Back to top ↑

Model Risk and Accountability Failure

Model risk is the possibility that a model produces harm because it is wrong, misused, misunderstood, outdated, biased, overtrusted, or poorly governed. Accountability failure occurs when no person or institution can explain, correct, or take responsibility for the model’s role in a decision.

Model risk cannot be eliminated entirely. It can be documented, reduced, monitored, and governed.

Back to top ↑

Mathematical Lens: Governance as Constraint, Review, and Lifecycle Control

Model governance can be represented as a constraint on model use:

Model risk can be represented as a function of error, uncertainty, consequence, and misuse:

Lifecycle monitoring can be represented as periodic review:

An escalation rule can be represented as:

These equations do not replace governance. They clarify that governance constrains model use, tracks risk, and updates model status over time.

Back to top ↑

Example: Governing a Public Infrastructure Risk Model

Consider a city using a mathematical model to prioritize infrastructure repairs. The model combines age of assets, maintenance history, weather exposure, service disruption, neighborhood vulnerability, and estimated failure risk.

The model may be useful, but it has governance requirements. It affects public investment. It may shift resources across neighborhoods. It may encode data gaps. It may rely on assumptions about future hazards. It may be interpreted as objective even when it embeds value choices.

The governed model may still support decision-making. But it does so as evidence within a responsible process, not as an automated authority.

Back to top ↑

Ethical Stakes of Model Governance

Model governance has ethical stakes because models often distribute attention, risk, resources, and credibility. A model can make some harms visible while hiding others. It can elevate certain values through its objective function. It can reinforce institutional blind spots. It can create a false sense of neutrality.

Ethical governance does not demand perfect models. It demands honest models, constrained models, reviewable models, and accountable model use.

Back to top ↑

Python Workflow: Model Governance Register and Review Queue

The Python workflow below creates a model governance register, scores governance risk, flags required actions, and writes a governance card suitable for review queues and decision-support documentation.

# model_governance_and_accountability_workflow.py
# Dependency-light workflow for model governance and accountability review.

from __future__ import annotations

from dataclasses import asdict, dataclass
from pathlib import Path
import csv
import json
import statistics


ARTICLE_ROOT = Path(__file__).resolve().parents[1]
OUTPUTS = ARTICLE_ROOT / "outputs"
TABLES = OUTPUTS / "tables"
JSON_DIR = OUTPUTS / "json"


@dataclass(frozen=True)
class ModelGovernanceRecord:
    key: str
    model_name: str
    model_purpose: str
    risk_tier: str
    validation_status: str
    use_limit_status: str
    monitoring_status: str
    model_owner: str
    decision_owner: str


@dataclass(frozen=True)
class GovernanceRiskCase:
    key: str
    model_name: str
    error_risk: float
    uncertainty_level: float
    consequence_level: float
    scope_misuse_risk: float
    accountability_gap: float


def governance_register() -> list[ModelGovernanceRecord]:
    return [
        ModelGovernanceRecord(
            "infrastructure_risk",
            "Infrastructure risk prioritization model",
            "planning support for repair prioritization",
            "high",
            "validated_with_limits",
            "approved_with_limits",
            "active",
            "infrastructure analytics team",
            "capital planning office",
        ),
        ModelGovernanceRecord(
            "public_health_demand",
            "Public health demand model",
            "scenario planning for service demand",
            "high",
            "review_required",
            "draft",
            "pending",
            "health modeling team",
            "public health operations",
        ),
        ModelGovernanceRecord(
            "supply_chain_resilience",
            "Supply chain resilience model",
            "stress testing supplier dependency",
            "medium",
            "validated_with_limits",
            "approved_with_limits",
            "active",
            "operations research group",
            "procurement leadership",
        ),
        ModelGovernanceRecord(
            "ai_triage_support",
            "AI-assisted triage support model",
            "decision support under clinical review",
            "critical",
            "review_required",
            "not_approved",
            "pending",
            "clinical analytics team",
            "clinical governance board",
        ),
    ]


def governance_risk_cases() -> list[GovernanceRiskCase]:
    return [
        GovernanceRiskCase("infrastructure_risk", "Infrastructure risk prioritization model", 0.38, 0.56, 0.82, 0.42, 0.24),
        GovernanceRiskCase("public_health_demand", "Public health demand model", 0.50, 0.68, 0.86, 0.48, 0.32),
        GovernanceRiskCase("supply_chain_resilience", "Supply chain resilience model", 0.36, 0.52, 0.65, 0.40, 0.22),
        GovernanceRiskCase("ai_triage_support", "AI-assisted triage support model", 0.62, 0.72, 0.95, 0.70, 0.55),
    ]


def governance_priority(record: ModelGovernanceRecord) -> float:
    score = {"low": 1.0, "medium": 3.0, "high": 6.0, "critical": 9.0}.get(
        record.risk_tier.lower(),
        4.0,
    )
    if record.validation_status != "validated_with_limits":
        score += 2.0
    if record.use_limit_status not in {"approved", "approved_with_limits"}:
        score += 2.0
    if record.monitoring_status != "active":
        score += 1.5
    if not record.model_owner or not record.decision_owner:
        score += 3.0
    return round(score, 8)


def evaluate_governance_risk(case: GovernanceRiskCase) -> dict[str, object]:
    governance_risk_score = (
        0.20 * case.error_risk
        + 0.20 * case.uncertainty_level
        + 0.25 * case.consequence_level
        + 0.20 * case.scope_misuse_risk
        + 0.15 * case.accountability_gap
    )

    if governance_risk_score >= 0.70:
        review_class = "escalation_required"
    elif governance_risk_score >= 0.55:
        review_class = "governance_review_required"
    else:
        review_class = "standard_monitoring"

    return {
        **asdict(case),
        "governance_risk_score": round(governance_risk_score, 8),
        "review_class": review_class,
        "requires_uncertainty_brief": case.uncertainty_level >= 0.60,
        "requires_use_limit_review": case.scope_misuse_risk >= 0.45,
        "requires_accountability_review": case.accountability_gap >= 0.30,
    }


def governance_summary(rows: list[dict[str, object]]) -> dict[str, object]:
    if not rows:
        raise ValueError("Governance summary requires at least one row.")
    scores = [float(row["governance_risk_score"]) for row in rows]
    highest = max(rows, key=lambda row: float(row["governance_risk_score"]))
    escalation_count = sum(1 for row in rows if row["review_class"] == "escalation_required")
    return {
        "highest_risk_model": highest["model_name"],
        "mean_governance_risk_score": round(statistics.mean(scores), 8),
        "max_governance_risk_score": round(max(scores), 8),
        "escalation_count": escalation_count,
        "case_count": len(rows),
    }


def write_csv(path: Path, rows: list[dict[str, object]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    if not rows:
        raise ValueError(f"No rows supplied for {path}")
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=list(rows[0].keys()))
        writer.writeheader()
        writer.writerows(rows)


def write_json(path: Path, payload: object) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    with path.open("w", encoding="utf-8") as handle:
        json.dump(payload, handle, indent=2, sort_keys=True)


def main() -> None:
    register = governance_register()
    risk_cases = governance_risk_cases()

    register_rows = [
        {**asdict(record), "governance_priority": governance_priority(record)}
        for record in register
    ]

    risk_rows = [evaluate_governance_risk(case) for case in risk_cases]

    write_csv(TABLES / "model_governance_register.csv", register_rows)
    write_csv(TABLES / "model_governance_risk_review.csv", risk_rows)

    write_json(JSON_DIR / "model_governance_card.json", {
        "article": "Model Governance and Accountability",
        "governance_summary": governance_summary(risk_rows),
        "model_governance_register": register_rows,
        "model_governance_risk_review": risk_rows,
        "use_limit": "This workflow supports model governance review and accountability documentation; it does not replace domain validation, legal review, ethical review, stakeholder engagement, or accountable decision ownership.",
        "diagnostic_checks": [
            "model purpose is recorded",
            "risk tier is recorded",
            "validation status is recorded",
            "use-limit status is recorded",
            "monitoring status is recorded",
            "model owner and decision owner are recorded",
            "risk review flags uncertainty, use-limit, and accountability review needs",
        ],
    })

    print("Model governance and accountability workflow complete.")
    print(f"Governance summary: {governance_summary(risk_rows)}")
    print(f"Wrote outputs to {OUTPUTS}")


if __name__ == "__main__":
    main()

This workflow treats governance as an auditable modeling layer. It preserves purpose, ownership, validation status, use limits, monitoring status, and escalation needs.

Back to top ↑

R Workflow: Governance Summary and Review Prioritization

The R workflow below reviews generated governance outputs, ranks models by governance priority and risk, summarizes escalation needs, and creates a base R diagnostic plot.

# model_governance_and_accountability_review.R
# Base R workflow for model governance and accountability review.

args <- commandArgs(trailingOnly = FALSE)
file_arg <- grep("^--file=", args, value = TRUE)

if (length(file_arg) > 0) {
  script_path <- normalizePath(sub("^--file=", "", file_arg[1]), mustWork = TRUE)
  article_root <- normalizePath(file.path(dirname(script_path), ".."), mustWork = TRUE)
} else {
  article_root <- getwd()
}

tables_dir <- file.path(article_root, "outputs", "tables")
figures_dir <- file.path(article_root, "outputs", "figures")
dir.create(tables_dir, recursive = TRUE, showWarnings = FALSE)
dir.create(figures_dir, recursive = TRUE, showWarnings = FALSE)

register_path <- file.path(tables_dir, "model_governance_register.csv")
risk_path <- file.path(tables_dir, "model_governance_risk_review.csv")

if (!file.exists(register_path) || !file.exists(risk_path)) {
  stop("Missing model governance outputs. Run the Python workflow first.")
}

register <- read.csv(register_path, stringsAsFactors = FALSE)
risk <- read.csv(risk_path, stringsAsFactors = FALSE)

register$governance_priority <- as.numeric(register$governance_priority)
risk$governance_risk_score <- as.numeric(risk$governance_risk_score)

register <- register[order(-register$governance_priority), ]
risk <- risk[order(-risk$governance_risk_score), ]

summary_table <- data.frame(
  highest_risk_model = risk$model_name[1],
  mean_governance_risk_score = mean(risk$governance_risk_score),
  max_governance_risk_score = max(risk$governance_risk_score),
  escalation_count = sum(risk$review_class == "escalation_required"),
  case_count = nrow(risk)
)

write.csv(
  register,
  file.path(tables_dir, "r_model_governance_review_queue.csv"),
  row.names = FALSE
)

write.csv(
  risk,
  file.path(tables_dir, "r_model_governance_risk_ranking.csv"),
  row.names = FALSE
)

write.csv(
  summary_table,
  file.path(tables_dir, "r_model_governance_summary.csv"),
  row.names = FALSE
)

png(file.path(figures_dir, "r_model_governance_risk_scores.png"), width = 1000, height = 700)

barplot(
  risk$governance_risk_score,
  names.arg = risk$key,
  las = 2,
  ylab = "Governance risk score",
  main = "Model Governance Risk Scores"
)

dev.off()

print(register)
print(summary_table)
print(risk)

The R layer supports review by preserving governance queues, risk rankings, and escalation summaries.

Back to top ↑

Haskell Workflow: Typed Governance Records

Haskell is useful here because governance roles and statuses should remain distinct. Model ownership is not decision ownership. Validation is not approval. Approval is not permanent permission. Deployment is not lifecycle stewardship.

{-# OPTIONS_GHC -Wall #-}

module Main where

data RiskTier
  = LowRisk
  | MediumRisk
  | HighRisk
  | CriticalRisk
  deriving (Eq, Show)

data ValidationStatus
  = NotValidated
  | ReviewRequired
  | ValidatedWithLimits
  | RetiredValidation
  deriving (Eq, Show)

data UseLimitStatus
  = NotApproved
  | DraftUseLimit
  | Approved
  | ApprovedWithLimits
  deriving (Eq, Show)

data MonitoringStatus
  = PendingMonitoring
  | ActiveMonitoring
  | IncidentReview
  | RetiredMonitoring
  deriving (Eq, Show)

data ModelGovernanceRecord = ModelGovernanceRecord
  { key :: String
  , modelName :: String
  , modelPurpose :: String
  , riskTier :: RiskTier
  , validationStatus :: ValidationStatus
  , useLimitStatus :: UseLimitStatus
  , monitoringStatus :: MonitoringStatus
  , modelOwner :: String
  , decisionOwner :: String
  } deriving (Eq, Show)

governanceRegister :: [ModelGovernanceRecord]
governanceRegister =
  [ ModelGovernanceRecord
      "infrastructure_risk"
      "Infrastructure risk prioritization model"
      "Planning support for repair prioritization"
      HighRisk
      ValidatedWithLimits
      ApprovedWithLimits
      ActiveMonitoring
      "Infrastructure analytics team"
      "Capital planning office"
  , ModelGovernanceRecord
      "public_health_demand"
      "Public health demand model"
      "Scenario planning for service demand"
      HighRisk
      ReviewRequired
      DraftUseLimit
      PendingMonitoring
      "Health modeling team"
      "Public health operations"
  , ModelGovernanceRecord
      "ai_triage_support"
      "AI-assisted triage support model"
      "Decision support under clinical review"
      CriticalRisk
      ReviewRequired
      NotApproved
      PendingMonitoring
      "Clinical analytics team"
      "Clinical governance board"
  ]

requiresGovernanceReview :: ModelGovernanceRecord -> Bool
requiresGovernanceReview item =
  validationStatus item /= ValidatedWithLimits
  || useLimitStatus item == NotApproved
  || monitoringStatus item /= ActiveMonitoring

main :: IO ()
main = do
  putStrLn "Typed model governance records:"
  mapM_ print governanceRegister

  putStrLn "\nRecords requiring governance review:"
  mapM_ print (filter requiresGovernanceReview governanceRegister)

This typed layer supports governance by keeping risk tier, validation status, use-limit status, monitoring status, model ownership, and decision ownership explicit.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It contains article-specific code, data, documentation, notebooks, schemas, and generated outputs for model governance registers, accountability records, validation status review, use-limit tracking, monitoring plans, escalation queues, typed governance records, and responsible model lifecycle workflows.

Back to top ↑

A Practical Method for Model Governance

Model governance works best when it is built into the modeling workflow from the beginning. Governance should not be added only after a model becomes controversial or fails.

This method ensures that the model remains connected to purpose, evidence, oversight, and responsibility across its life.

Back to top ↑

Common Pitfalls

Model governance can fail when it is treated as paperwork rather than responsibility. The point is not to create forms. The point is to make model use reviewable and accountable.

• Governance after deployment: waiting until the model is already influencing decisions before defining oversight.
• Single approval forever: treating initial validation as permanent permission.
• Unclear ownership: failing to distinguish model owner from decision owner.
• Documentation theater: creating records that do not actually explain assumptions, data, limits, or use.
• Validation overclaiming: saying a model is validated without specifying domain, evidence, or limits.
• Dashboard authority: allowing polished interfaces to hide uncertainty and judgment.
• Scope creep: reusing a model for purposes beyond its approved domain.
• No incident pathway: lacking a process for harm, error, misuse, or performance decay.
• Retirement avoidance: keeping models alive because institutions are accustomed to them.
• Accountability displacement: blaming the model instead of the institution that used it.

These pitfalls can be reduced through lifecycle governance, independent review, use limits, monitoring, incident escalation, and explicit decision ownership.

Back to top ↑

Conclusion: Models Support Judgment, Institutions Own Responsibility

Model governance and accountability are essential because models are powerful but limited tools. They can clarify systems, estimate uncertainty, compare scenarios, and support decisions. They can also mislead when they are undocumented, unvalidated, overextended, unmonitored, or treated as neutral authority.

Responsible governance does not require perfect models. It requires transparent purpose, documented assumptions, reliable provenance, validation for intended use, clear use limits, monitoring, review, revision, and retirement.

Most importantly, governance requires accountability. A model cannot own a decision. An equation cannot answer for consequences. A dashboard cannot bear responsibility. A model may support judgment, but people and institutions remain responsible for how model-based claims are interpreted and used.

Good governance keeps mathematical modeling both useful and humble: powerful enough to support learning, but constrained enough to remain answerable to evidence, values, and responsibility.

Back to top ↑

Related Articles

• What Is Mathematical Modeling?
• Model Purpose: Explanation, Prediction, Control, and Decision Support
• Validation and Model Assessment
• Model Comparison and Selection
• Overfitting, Underfitting, and Model Generalization
• Diagnostics, Residuals, and Model Error
• Communicating Model Uncertainty
• Limits, Failure, and the Ethics of Modeling
• Mathematical Modeling in an Age of Complexity
• AI-Assisted Modeling and Human Judgment

Back to top ↑

Further Reading

• Barocas, S., Hardt, M. and Narayanan, A. (2023) Fairness and Machine Learning: Limitations and Opportunities. Cambridge, MA: MIT Press.
• Box, G.E.P. and Draper, N.R. (1987) Empirical Model-Building and Response Surfaces. New York: Wiley.
• Jasanoff, S. (2016) The Ethics of Invention: Technology and the Human Future. New York: W.W. Norton.
• National Academies of Sciences, Engineering, and Medicine (2019) Reproducibility and Replicability in Science. Washington, DC: National Academies Press.
• National Institute of Standards and Technology (2023) Artificial Intelligence Risk Management Framework (AI RMF 1.0). Gaithersburg, MD: NIST.
• O’Neil, C. (2016) Weapons of Math Destruction: How Big Data Increases Inequality and Threatens Democracy. New York: Crown.
• Raji, I.D. et al. (2020) ‘Closing the AI accountability gap: Defining an end-to-end framework for internal algorithmic auditing’, Proceedings of the 2020 Conference on Fairness, Accountability, and Transparency, pp. 33–44.
• Saltelli, A. et al. (2020) ‘Five ways to ensure that models serve society: a manifesto’, Nature, 582, pp. 482–484.
• Saltelli, A., Tarantola, S., Campolongo, F. and Ratto, M. (2008) Global Sensitivity Analysis: The Primer. Chichester: Wiley.
• Sterman, J.D. (2000) Business Dynamics: Systems Thinking and Modeling for a Complex World. Boston: Irwin/McGraw-Hill.

Back to top ↑

References

• Barocas, S., Hardt, M. and Narayanan, A. (2023) Fairness and Machine Learning: Limitations and Opportunities. Cambridge, MA: MIT Press.
• Box, G.E.P. and Draper, N.R. (1987) Empirical Model-Building and Response Surfaces. New York: Wiley.
• Jasanoff, S. (2016) The Ethics of Invention: Technology and the Human Future. New York: W.W. Norton.
• National Academies of Sciences, Engineering, and Medicine (2019) Reproducibility and Replicability in Science. Washington, DC: National Academies Press.
• National Institute of Standards and Technology (2023) Artificial Intelligence Risk Management Framework (AI RMF 1.0). Gaithersburg, MD: NIST.
• O’Neil, C. (2016) Weapons of Math Destruction: How Big Data Increases Inequality and Threatens Democracy. New York: Crown.
• Raji, I.D. et al. (2020) ‘Closing the AI accountability gap: Defining an end-to-end framework for internal algorithmic auditing’, Proceedings of the 2020 Conference on Fairness, Accountability, and Transparency, pp. 33–44.
• Saltelli, A. et al. (2020) ‘Five ways to ensure that models serve society: a manifesto’, Nature, 582, pp. 482–484.
• Saltelli, A., Tarantola, S., Campolongo, F. and Ratto, M. (2008) Global Sensitivity Analysis: The Primer. Chichester: Wiley.
• Sterman, J.D. (2000) Business Dynamics: Systems Thinking and Modeling for a Complex World. Boston: Irwin/McGraw-Hill.

Back to top ↑