AI-Assisted Modeling and Human Judgment: How Mathematical Models, Artificial Intelligence, and Human Oversight Should Work Together

Last Updated June 13, 2026

AI-assisted modeling and human judgment examines how artificial intelligence can support mathematical modeling without replacing responsible interpretation, domain expertise, ethical review, and decision ownership. AI systems can help generate hypotheses, organize data, propose model structures, write code, compare scenarios, detect anomalies, summarize results, and accelerate documentation.

But AI assistance also creates risks. It can produce plausible but false explanations. It can suggest model structures without understanding context. It can hide assumptions behind polished language. It can encourage automation bias. It can make weak evidence appear authoritative. It can blur the line between support and decision authority.

Responsible AI-assisted modeling keeps the roles clear. AI may assist with exploration, computation, documentation, synthesis, and review. Human judgment remains responsible for purpose, evidence, assumptions, validation, uncertainty, ethics, interpretation, consequences, and final use.

AI assistance changes the speed and scale of modeling work. It does not eliminate the need for mathematical care. The faster a model can be drafted, coded, summarized, and visualized, the more important it becomes to preserve review, provenance, validation, uncertainty, and accountability.

Why AI-Assisted Modeling Matters

AI-assisted modeling matters because modeling work is becoming faster, more automated, and more accessible. AI systems can help write code, suggest equations, summarize literature, generate visualizations, test alternative assumptions, produce documentation, and compare outputs. This can lower barriers to modeling and improve productivity.

But speed is not the same as reliability. A model generated quickly still needs conceptual review. A clean explanation still needs evidence. A working script still needs validation. A plausible equation still needs domain meaning. A polished summary still needs uncertainty and accountability.

The central question is not whether AI can help. It can. The question is how to use AI without surrendering judgment to it.

Back to top ↑

What AI Can Assist in Mathematical Modeling

AI can assist many parts of the modeling workflow. It can accelerate ideation, formatting, coding, testing, synthesis, documentation, and review. It can help expose blind spots by generating alternative assumptions or asking diagnostic questions. It can help translate technical findings for different audiences.

AI assistance is most useful when its outputs are treated as drafts, prompts, candidate artifacts, or review aids rather than verified conclusions.

AI assistance is strongest when the workflow already has standards. Without standards, AI can make weak modeling look more complete than it is.

Back to top ↑

What AI Cannot Own: Purpose, Judgment, and Responsibility

AI systems cannot own the purpose of a model. They cannot decide what matters ethically. They cannot bear responsibility for consequences. They cannot know whether a simplified representation is legitimate for a community, institution, environment, or decision context. They cannot replace accountability.

A model may use AI assistance, but the responsibility remains human and institutional. Someone must decide what the model is for, what evidence is acceptable, what assumptions are defensible, what uncertainty matters, what harms are possible, and what decision the model is allowed to support.

AI can support modeling work. It cannot become the moral, institutional, or legal subject responsible for how modeling is used.

Back to top ↑

Human Judgment in the Modeling Process

Human judgment is present throughout modeling. It appears when a problem is framed, when a boundary is drawn, when a variable is selected, when a proxy is accepted, when a parameter is estimated, when a result is interpreted, and when a decision is made.

AI assistance does not remove judgment. It can hide judgment unless the workflow makes human choices visible.

Responsible modeling names these judgment points instead of burying them inside technical workflow.

Back to top ↑

Risks of AI-Assisted Modeling

AI assistance can improve modeling productivity, but it also introduces distinctive risks. These risks are not only computational. They include conceptual, epistemic, ethical, organizational, and communicative risks.

The purpose of governance is not to block AI assistance. It is to keep assistance from becoming unreviewed authority.

Back to top ↑

Automation Bias and False Authority

Automation bias occurs when people give too much weight to system-generated outputs. AI-assisted modeling can intensify this bias because AI outputs are often fluent, confident, and well-formatted. A polished model explanation may feel more reliable than it is.

False authority is especially dangerous when AI-generated outputs are embedded in dashboards, reports, code repositories, or decision workflows without clear review status. Users may not know whether the output is exploratory, validated, provisional, reviewed, or approved for decision support.

AI-assisted modeling should label output status clearly. Without status labels, exploratory outputs can accidentally become decision evidence.

Back to top ↑

Provenance, Reproducibility, and Audit Trails

Provenance is the record of where model ingredients came from: data, assumptions, code, prompts, references, parameter values, transformations, validation results, and review decisions. AI assistance makes provenance more important because model artifacts can be generated quickly and modified repeatedly.

Reproducibility means that another reviewer can understand and rerun the workflow. Audit trails make it possible to see what changed, who reviewed it, and why a model was approved, revised, or rejected.

AI assistance should leave a trace. A model that cannot be audited should not be trusted for consequential use.

Back to top ↑

Uncertainty, Validation, and Model Review

AI can help estimate uncertainty, generate sensitivity checks, produce validation scripts, and summarize diagnostics. But AI-generated validation is not the same as validation. Validation requires comparison with evidence, domain review, stress testing, error analysis, and assessment of intended use.

AI-assisted workflows should treat uncertainty and validation as mandatory review layers, not optional polish.

Validation is a human-governed evidence process. AI can assist it, but cannot certify itself.

Back to top ↑

Designing the AI-Human Modeling Relationship

AI-assisted modeling works best when roles are designed intentionally. The workflow should define what AI may do, what humans must review, what requires escalation, and what cannot be delegated.

A useful design principle is to treat AI as a junior modeling assistant, not as an autonomous model authority. It can suggest, draft, compare, summarize, and flag. It should not approve, certify, decide, or own consequences.

Clear role design reduces confusion between assistance and authority.

Back to top ↑

Escalation, Oversight, and Decision Ownership

Not every AI-assisted modeling output requires the same level of oversight. Exploratory models may need light review. High-stakes models need formal validation, ethical review, stakeholder consideration, security review, monitoring, and decision ownership.

Escalation rules define when a model moves from exploration to review, from review to validation, and from validation to approved use.

Decision ownership must be explicit. A decision owner cannot hide behind AI output, and a model owner cannot assume deployment is harmless because the tool was helpful during analysis.

Back to top ↑

Governance for AI-Assisted Modeling

AI-assisted modeling needs governance because the workflow combines formal modeling, computational automation, probabilistic uncertainty, human values, and institutional responsibility. Governance turns AI assistance into a reviewable process.

Governance should not be added after AI has produced a model. It should shape how AI assistance is used from the start.

Back to top ↑

Mathematical Lens: Assistance, Judgment, Loss, and Accountability

An AI-assisted modeling workflow can be represented as a combination of data, assumptions, AI assistance, and human judgment:

AI assistance can be represented as a candidate generator:

Human review maps candidate artifacts into approved, revised, rejected, or escalated status:

Decision loss depends on the consequences of using the model:

Use should be constrained by validation and governance:

The mathematical lesson is that AI assistance should be modeled as part of a larger decision process, not as a replacement for that process.

Back to top ↑

Example: AI-Assisted Scenario Modeling for Public Systems

Consider a public agency using AI to support scenario modeling for infrastructure stress, climate exposure, and service access. AI can help draft scenarios, organize datasets, produce code, generate charts, and summarize model outputs. But each AI-assisted artifact must be reviewed before it informs planning.

The responsible workflow uses AI to accelerate analysis, but the agency retains accountability for what is modeled, what is excluded, what evidence is sufficient, what communities are affected, and what decisions are made.

Back to top ↑

Ethical Stakes of AI-Assisted Modeling

AI-assisted modeling has ethical stakes because models often influence decisions that affect resources, safety, access, rights, policy, sustainability, and public trust. AI can make modeling more productive, but it can also obscure who made which choice and why.

The ethical standard is not “AI was involved.” The standard is whether the AI-assisted process remains transparent, reviewable, validated, limited, accountable, and aligned with the people and systems affected by the model.

Back to top ↑

Python Workflow: AI Assistance Review and Human Judgment Register

The Python workflow below creates an AI assistance register, scores review needs, tracks human judgment ownership, and writes a governance card for AI-assisted modeling.

# ai_assisted_modeling_and_human_judgment_workflow.py
# Dependency-light workflow for AI assistance review and human judgment governance.

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 AIAssistanceRecord:
    key: str
    modeling_stage: str
    ai_role: str
    artifact_type: str
    provenance_required: bool
    human_review_required: bool
    status: str


@dataclass(frozen=True)
class HumanJudgmentCase:
    key: str
    judgment_point: str
    decision_context: str
    evidence_strength: float
    uncertainty_level: float
    consequence_level: float
    automation_bias_risk: float
    accountability_clarity: float


def ai_assistance_register() -> list[AIAssistanceRecord]:
    return [
        AIAssistanceRecord(
            "scenario_drafting",
            "scenario_design",
            "idea_generator",
            "scenario_list",
            True,
            True,
            "review",
        ),
        AIAssistanceRecord(
            "code_generation",
            "computation",
            "code_assistant",
            "model_script",
            True,
            True,
            "review",
        ),
        AIAssistanceRecord(
            "diagnostic_summary",
            "validation",
            "diagnostic_aide",
            "diagnostic_report",
            True,
            True,
            "review",
        ),
        AIAssistanceRecord(
            "communication_draft",
            "communication",
            "documentation_assistant",
            "public_summary",
            True,
            True,
            "review",
        ),
        AIAssistanceRecord(
            "governance_template",
            "governance",
            "review_companion",
            "use_limit_statement",
            True,
            True,
            "active",
        ),
    ]


def human_judgment_cases() -> list[HumanJudgmentCase]:
    return [
        HumanJudgmentCase("problem_frame", "problem framing", "public infrastructure stress model", 0.72, 0.58, 0.80, 0.45, 0.70),
        HumanJudgmentCase("data_fit", "data fitness judgment", "using administrative records", 0.62, 0.66, 0.75, 0.50, 0.65),
        HumanJudgmentCase("model_use", "approved use decision", "moving from exploratory to decision support", 0.68, 0.70, 0.88, 0.72, 0.55),
        HumanJudgmentCase("public_summary", "communication approval", "publishing model results", 0.76, 0.62, 0.82, 0.60, 0.72),
    ]


def review_priority(record: AIAssistanceRecord) -> float:
    score = {"active": 1.0, "review": 5.0, "revise": 8.0, "archive": 2.0}.get(
        record.status.lower(),
        4.0,
    )
    if record.provenance_required:
        score += 1.0
    if record.human_review_required:
        score += 1.0
    if record.artifact_type in {"model_script", "diagnostic_report", "public_summary", "use_limit_statement"}:
        score += 1.0
    return round(score, 8)


def evaluate_judgment_case(case: HumanJudgmentCase) -> dict[str, object]:
    risk_score = (
        0.25 * (1.0 - case.evidence_strength)
        + 0.25 * case.uncertainty_level
        + 0.25 * case.consequence_level
        + 0.15 * case.automation_bias_risk
        + 0.10 * (1.0 - case.accountability_clarity)
    )

    if risk_score >= 0.65:
        review_class = "escalation_required"
    elif risk_score >= 0.50:
        review_class = "human_review_required"
    else:
        review_class = "standard_review"

    return {
        **asdict(case),
        "judgment_risk_score": round(risk_score, 8),
        "review_class": review_class,
        "requires_use_limit_statement": case.consequence_level >= 0.70,
        "requires_uncertainty_brief": case.uncertainty_level >= 0.60,
        "requires_accountability_owner": case.accountability_clarity < 0.70,
    }


def judgment_summary(rows: list[dict[str, object]]) -> dict[str, object]:
    if not rows:
        raise ValueError("Judgment summary requires at least one row.")
    risk_scores = [float(row["judgment_risk_score"]) for row in rows]
    highest = max(rows, key=lambda row: float(row["judgment_risk_score"]))
    escalation_count = sum(1 for row in rows if row["review_class"] == "escalation_required")
    return {
        "highest_risk_judgment_point": highest["judgment_point"],
        "mean_judgment_risk_score": round(statistics.mean(risk_scores), 8),
        "max_judgment_risk_score": round(max(risk_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:
    assistance_records = ai_assistance_register()
    judgment_cases = human_judgment_cases()

    assistance_rows = [
        {**asdict(record), "review_priority": review_priority(record)}
        for record in assistance_records
    ]

    judgment_rows = [evaluate_judgment_case(case) for case in judgment_cases]

    write_csv(TABLES / "ai_assistance_register.csv", assistance_rows)
    write_csv(TABLES / "human_judgment_review.csv", judgment_rows)

    write_json(JSON_DIR / "ai_assisted_modeling_governance_card.json", {
        "article": "AI-Assisted Modeling and Human Judgment",
        "judgment_summary": judgment_summary(judgment_rows),
        "ai_assistance_register": assistance_rows,
        "human_judgment_review": judgment_rows,
        "use_limit": "This workflow supports AI-assisted modeling review, provenance tracking, and human judgment governance; it does not permit AI-generated artifacts to serve as final decision authority without human review, validation, and accountability.",
        "diagnostic_checks": [
            "AI assistance role is recorded",
            "artifact type is recorded",
            "provenance requirement is explicit",
            "human review requirement is explicit",
            "judgment risk is scored",
            "use-limit and uncertainty briefs are flagged",
            "accountability owner requirement is preserved",
        ],
    })

    print("AI-assisted modeling and human judgment workflow complete.")
    print(f"Judgment summary: {judgment_summary(judgment_rows)}")
    print(f"Wrote outputs to {OUTPUTS}")


if __name__ == "__main__":
    main()

This workflow treats AI assistance as a documented part of modeling governance. It records where AI helped, what artifacts were produced, what review is required, and where human judgment must remain accountable.

Back to top ↑

R Workflow: AI-Assisted Modeling Oversight Summary

The R workflow below reviews generated AI assistance outputs, ranks judgment points by risk, summarizes escalation needs, and creates a base R oversight plot.

# ai_assisted_modeling_and_human_judgment_review.R
# Base R workflow for AI-assisted modeling oversight.

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)

assistance_path <- file.path(tables_dir, "ai_assistance_register.csv")
judgment_path <- file.path(tables_dir, "human_judgment_review.csv")

if (!file.exists(assistance_path) || !file.exists(judgment_path)) {
  stop("Missing AI-assisted modeling outputs. Run the Python workflow first.")
}

assistance <- read.csv(assistance_path, stringsAsFactors = FALSE)
judgment <- read.csv(judgment_path, stringsAsFactors = FALSE)

assistance$review_priority <- as.numeric(assistance$review_priority)
judgment$judgment_risk_score <- as.numeric(judgment$judgment_risk_score)

assistance <- assistance[order(-assistance$review_priority), ]
judgment <- judgment[order(-judgment$judgment_risk_score), ]

summary_table <- data.frame(
  highest_risk_judgment_point = judgment$judgment_point[1],
  mean_judgment_risk_score = mean(judgment$judgment_risk_score),
  max_judgment_risk_score = max(judgment$judgment_risk_score),
  escalation_count = sum(judgment$review_class == "escalation_required"),
  case_count = nrow(judgment)
)

write.csv(
  assistance,
  file.path(tables_dir, "r_ai_assistance_review_queue.csv"),
  row.names = FALSE
)

write.csv(
  judgment,
  file.path(tables_dir, "r_human_judgment_risk_ranking.csv"),
  row.names = FALSE
)

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

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

barplot(
  judgment$judgment_risk_score,
  names.arg = judgment$key,
  las = 2,
  ylab = "Judgment risk score",
  main = "AI-Assisted Modeling Human Judgment Risk Scores"
)

dev.off()

print(assistance)
print(summary_table)
print(judgment)

The R layer supports review by preserving an AI-assistance queue, a human-judgment risk ranking, and an oversight summary.

Back to top ↑

Haskell Workflow: Typed AI Assistance Records

Haskell is useful here because AI-assisted modeling roles should remain distinct. A draft is not validation. A suggestion is not evidence. A summary is not accountability. A generated model artifact is not an approved decision tool.

{-# OPTIONS_GHC -Wall #-}

module Main where

data ModelingStage
  = ProblemFraming
  | ScenarioDesign
  | Computation
  | Validation
  | Communication
  | Governance
  deriving (Eq, Show)

data AIRole
  = IdeaGenerator
  | CodeAssistant
  | DiagnosticAide
  | DocumentationAssistant
  | ReviewCompanion
  deriving (Eq, Show)

data ArtifactType
  = ScenarioList
  | ModelScript
  | DiagnosticReport
  | PublicSummary
  | UseLimitStatement
  deriving (Eq, Show)

data ReviewStatus
  = Exploratory
  | Draft
  | RequiresReview
  | Approved
  | Retired
  deriving (Eq, Show)

data AIAssistanceRecord = AIAssistanceRecord
  { key :: String
  , stage :: ModelingStage
  , aiRole :: AIRole
  , artifactType :: ArtifactType
  , provenanceRequired :: Bool
  , humanReviewRequired :: Bool
  , status :: ReviewStatus
  } deriving (Eq, Show)

aiAssistanceRegister :: [AIAssistanceRecord]
aiAssistanceRegister =
  [ AIAssistanceRecord "scenario_drafting" ScenarioDesign IdeaGenerator ScenarioList True True RequiresReview
  , AIAssistanceRecord "code_generation" Computation CodeAssistant ModelScript True True RequiresReview
  , AIAssistanceRecord "diagnostic_summary" Validation DiagnosticAide DiagnosticReport True True RequiresReview
  , AIAssistanceRecord "communication_draft" Communication DocumentationAssistant PublicSummary True True RequiresReview
  , AIAssistanceRecord "governance_template" Governance ReviewCompanion UseLimitStatement True True Draft
  ]

requiresHumanReview :: AIAssistanceRecord -> Bool
requiresHumanReview item = humanReviewRequired item || status item == RequiresReview

main :: IO ()
main = do
  putStrLn "Typed AI assistance records:"
  mapM_ print aiAssistanceRegister

  putStrLn "\nRecords requiring human review:"
  mapM_ print (filter requiresHumanReview aiAssistanceRegister)

This typed layer supports AI-assisted modeling governance by keeping modeling stage, AI role, artifact type, provenance requirement, human review requirement, and review status 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 AI assistance registers, human judgment review, automation-bias risk scoring, provenance tracking, escalation flags, use-limit records, typed AI assistance records, and responsible AI-assisted modeling workflows.

Back to top ↑

A Practical Method for AI-Assisted Modeling

AI-assisted modeling should follow a process that preserves human judgment and reproducibility. The method below treats AI assistance as a managed input, not as an unreviewed authority.

The method keeps AI assistance useful without allowing it to erase the human decisions embedded in modeling.

Back to top ↑

Common Pitfalls

AI-assisted modeling can fail when convenience replaces review. The main danger is not that AI is used, but that AI-generated artifacts appear finished before they are tested, interpreted, and governed.

• Draft-as-final error: treating AI-generated text, equations, or code as approved work.
• Provenance loss: failing to record where assumptions, prompts, data, or code came from.
• Silent assumption drift: letting AI alter the model’s logic without explicit review.
• Automation bias: giving extra authority to outputs because they are generated fluently.
• Validation theater: generating diagnostic language without meaningful testing.
• Code confidence: assuming running code is correct code.
• Uncertainty omission: summarizing results without sensitivity, confidence, or use limits.
• Scope creep: using exploratory AI-assisted models for consequential decisions.
• Accountability evasion: blaming AI rather than the people who used it.
• Human rubber-stamping: preserving a nominal review step that does not meaningfully challenge the output.

These pitfalls can be reduced by treating AI outputs as candidates, preserving audit trails, requiring human review, testing code, communicating uncertainty, and assigning decision ownership.

Back to top ↑

Conclusion: AI in the Toolkit, Judgment in Control

AI-assisted modeling can make mathematical modeling faster, broader, and more accessible. It can help generate ideas, write code, compare assumptions, organize workflows, summarize diagnostics, and document models. Used carefully, it can improve the modeling process.

But AI assistance does not remove the need for judgment. It increases the need for review, provenance, validation, uncertainty communication, governance, and accountability. The more fluent and automated the workflow becomes, the more important it is to keep human responsibility visible.

Models already require judgment. AI-assisted models require even more explicit judgment because assistance can make uncertainty, assumptions, and values look settled before they are examined.

The right principle is simple: AI belongs in the toolkit, never in control. Human judgment must remain responsible for purpose, evidence, interpretation, values, consequences, and use.

Back to top ↑

Related Articles

• What Is Mathematical Modeling?
• Model Purpose: Explanation, Prediction, Control, and Decision Support
• Model Interpretation and Decision-Making
• Mathematical Modeling in Artificial Intelligence and Data Systems
• Limits, Failure, and the Ethics of Modeling
• Mathematical Modeling in an Age of Complexity
• Model Governance and Accountability
• Communicating Model Uncertainty
• Validation and Model Assessment
• Future Directions in Mathematical Modeling

Back to top ↑

Further Reading

• Amodei, D. et al. (2016) ‘Concrete problems in AI safety’, arXiv.
• Barocas, S., Hardt, M. and Narayanan, A. (2023) Fairness and Machine Learning: Limitations and Opportunities. Cambridge, MA: MIT Press.
• Bostrom, N. (2014) Superintelligence: Paths, Dangers, Strategies. Oxford: Oxford University Press.
• Epstein, J.M. (2008) ‘Why model?’, Journal of Artificial Societies and Social Simulation, 11(4).
• Jasanoff, S. (2016) The Ethics of Invention: Technology and the Human Future. New York: W.W. Norton.
• Mitchell, M. (2019) Artificial Intelligence: A Guide for Thinking Humans. New York: Farrar, Straus and Giroux.
• Mittelstadt, B.D., Allo, P., Taddeo, M., Wachter, S. and Floridi, L. (2016) ‘The ethics of algorithms: Mapping the debate’, Big Data & Society, 3(2).
• 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.
• Russell, S. (2019) Human Compatible: Artificial Intelligence and the Problem of Control. New York: Viking.
• Saltelli, A. et al. (2020) ‘Five ways to ensure that models serve society: a manifesto’, Nature, 582, pp. 482–484.

Back to top ↑

References

• Amodei, D. et al. (2016) ‘Concrete problems in AI safety’, arXiv.
• Barocas, S., Hardt, M. and Narayanan, A. (2023) Fairness and Machine Learning: Limitations and Opportunities. Cambridge, MA: MIT Press.
• Bostrom, N. (2014) Superintelligence: Paths, Dangers, Strategies. Oxford: Oxford University Press.
• Epstein, J.M. (2008) ‘Why model?’, Journal of Artificial Societies and Social Simulation, 11(4).
• Jasanoff, S. (2016) The Ethics of Invention: Technology and the Human Future. New York: W.W. Norton.
• Mitchell, M. (2019) Artificial Intelligence: A Guide for Thinking Humans. New York: Farrar, Straus and Giroux.
• Mittelstadt, B.D., Allo, P., Taddeo, M., Wachter, S. and Floridi, L. (2016) ‘The ethics of algorithms: Mapping the debate’, Big Data & Society, 3(2).
• 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.
• Russell, S. (2019) Human Compatible: Artificial Intelligence and the Problem of Control. New York: Viking.
• Saltelli, A. et al. (2020) ‘Five ways to ensure that models serve society: a manifesto’, Nature, 582, pp. 482–484.

Back to top ↑