Algorithms in Public Policy and Governance: Due Process, Accountability, and Public Power

Last Updated June 22, 2026

Algorithms in public policy and governance examine how computational systems are used to support, structure, prioritize, automate, or contest administrative decisions. Public institutions increasingly use algorithms for eligibility screening, benefits administration, risk scoring, fraud detection, inspection targeting, service triage, resource allocation, public-health surveillance, regulatory enforcement, policy evaluation, and administrative accountability. These systems can help governments process complexity, but they also raise serious questions about legality, fairness, due process, transparency, democratic legitimacy, and institutional responsibility.

Public policy algorithms do not operate in neutral space. They operate inside laws, agencies, budgets, political pressures, administrative histories, data infrastructures, procurement systems, and public obligations. A model that ranks cases, flags risk, routes applications, or detects anomalies can change how people experience the state. It can expand access, reduce delay, and improve consistency; it can also obscure responsibility, intensify surveillance, reproduce inequity, or make public decisions harder to challenge.

This article introduces algorithms in public policy and governance, automated eligibility, risk scoring, triage, fraud detection, public-service delivery, administrative accountability, due process, transparency, contestability, audit trails, procurement, public-sector AI governance, democratic legitimacy, human review, impact assessment, and institutional responsibility. It shows why public algorithmic systems must be judged not only by accuracy or efficiency, but by whether they serve lawful, fair, transparent, contestable, and accountable governance.

This article explains how algorithms support public policy and governance through eligibility screening, risk scoring, triage, fraud detection, service routing, regulatory targeting, resource allocation, policy evaluation, administrative records, audit trails, appeal pathways, and public-sector AI governance. It emphasizes that public algorithmic systems must be evaluated in relation to law, rights, due process, public purpose, institutional capacity, and democratic accountability.

Why Algorithms in Public Policy and Governance Matter

Algorithms in public policy and governance matter because public institutions make decisions that affect rights, benefits, burdens, access, risk, enforcement, opportunity, and public trust. When algorithms are used in these settings, they become part of the machinery of governance. A scoring model may decide which family receives review. A fraud system may trigger investigation. A benefits algorithm may determine whether someone is eligible for support. A predictive inspection tool may determine which buildings, employers, facilities, or neighborhoods receive scrutiny.

Public algorithms are not merely technical systems. They are administrative systems with public consequences.

Back to top ↑

Public Policy Algorithms Defined

A public policy algorithm is a computational procedure used to support or structure decisions made by public institutions, public contractors, regulatory bodies, service providers, or governance platforms. These algorithms may be simple rule systems, scoring formulas, statistical models, machine learning systems, optimization routines, ranking systems, simulation models, or workflow automations.

The defining feature is not technical sophistication. The defining feature is governance context. A spreadsheet rule used to deny a benefit may be more consequential than a complex model used only for internal planning. Public policy algorithms should therefore be assessed by their role in decision-making, not only by their method.

In public governance, even simple algorithms can carry serious administrative authority.

Back to top ↑

Automated Eligibility and Benefits Administration

Eligibility systems determine access to public benefits, permits, services, subsidies, housing assistance, health programs, emergency aid, licensing, education support, or other government-administered resources. Algorithms may apply rules, check documentation, compare records, calculate thresholds, route applications, or flag inconsistencies.

Eligibility automation can reduce delay and improve consistency, but it can also magnify bureaucratic error. Missing records, outdated data, rigid rules, language barriers, address instability, disability, immigration complexity, family changes, and documentation gaps can all lead to wrongful denial, delay, or burden.

An eligibility system should reduce administrative burden, not turn public support into an opaque maze.

Back to top ↑

Risk Scoring and Prioritization

Risk scores are used to prioritize cases for attention, intervention, inspection, support, investigation, or enforcement. They may estimate likelihood of harm, noncompliance, need, fraud, failure, instability, vulnerability, or recurrence. In public policy, risk scores often appear in child welfare, criminal justice, public health, housing, tax, environmental enforcement, social services, and emergency management.

Risk scoring is especially sensitive because it can change how people are treated. A score can trigger scrutiny, surveillance, denial, escalation, or intervention. It can also direct help toward people in need. The governance question is whether the score is valid, fair, lawful, proportional, contestable, and connected to useful action.

Risk scores should not become a substitute for public judgment, evidence, or care.

Back to top ↑

Triage and Public-Service Delivery

Public-service triage systems route requests, prioritize cases, assign staff, escalate emergencies, schedule inspections, manage queues, and allocate attention. Triage can improve service delivery when resources are limited, but it can also hide rationing decisions.

A triage algorithm may determine who receives attention quickly, who waits, who is redirected, and who falls through the cracks. Public institutions should therefore document triage criteria, wait-time effects, accessibility, language support, disability accommodations, equity impacts, and escalation pathways.

Triage should make public service more responsive, not less accountable.

Back to top ↑

Fraud Detection and Anomaly Scoring

Fraud detection systems search for unusual patterns, inconsistencies, duplicate claims, suspicious transactions, network anomalies, or behavior that differs from expected norms. In public governance, these systems may be used for tax, benefits, procurement, public contracting, health claims, unemployment insurance, grants, and licensing.

Fraud detection is important, but it is also high-risk. An anomaly is not proof of fraud. Data errors, life complexity, administrative mismatch, naming variation, address instability, disability, language issues, and changing circumstances can all appear anomalous. If fraud systems trigger penalties or benefit interruptions without meaningful review, they can create serious harm.

Public fraud detection must protect public resources without treating administrative irregularity as guilt.

Back to top ↑

Regulatory Enforcement and Inspection Targeting

Regulatory agencies may use algorithms to target inspections, audits, enforcement actions, environmental monitoring, workplace safety reviews, food safety checks, housing code inspections, tax audits, procurement oversight, or consumer protection investigations. These systems can help agencies focus limited resources on higher-risk cases.

But enforcement targeting must be governed carefully. Data availability can distort attention. Well-documented communities may be scrutinized more than hidden risks. Prior enforcement can create feedback loops. Businesses, landlords, facilities, or neighborhoods may be ranked by proxies rather than direct evidence of harm.

Enforcement algorithms should improve public protection without automating unequal scrutiny.

Back to top ↑

Resource Allocation and Public Value

Public institutions allocate limited resources: staff time, inspections, benefits, grants, services, emergency response, infrastructure investment, health interventions, housing support, education funding, and environmental remediation. Algorithms can optimize allocation under constraints, compare scenarios, and identify need.

But public allocation is not just efficiency. It involves public value, equity, legal obligations, historical disadvantage, geography, political accountability, and long-term effects. Optimization models can hide these choices if objectives are narrow or constraints are poorly defined.

Public-resource algorithms should optimize for public purpose, not merely administrative convenience.

Back to top ↑

Data Infrastructure and Administrative Records

Public algorithms depend on administrative data: applications, claims, case notes, inspections, complaints, addresses, payments, licenses, sensor readings, enforcement records, service interactions, and historical decisions. These data are not neutral measurements of reality. They are records created by institutional processes.

Administrative data can reflect unequal access, underreporting, surveillance, past discrimination, inconsistent entry, missing documentation, outdated systems, and policy changes. If algorithms treat these records as complete truth, public decisions may reproduce administrative history rather than evaluate present need or legal entitlement.

Public data are administrative artifacts. They require context before computation.

Back to top ↑

Due Process, Notice, and Appeals

When public algorithms affect rights, benefits, burdens, eligibility, enforcement, or access, affected people need meaningful procedural protections. They should know when an algorithm influenced a decision, receive understandable reasons, be able to inspect or correct relevant data, submit context, appeal outcomes, and obtain remedy when errors occur.

A system that produces decisions faster but makes them harder to challenge is not necessarily better governance. Public algorithmic systems must be designed for contestability from the start.

Public algorithmic governance must make challenge possible, not merely decision-making efficient.

Back to top ↑

Transparency, Explainability, and Public Reasons

Transparency in public algorithmic systems is not merely publishing technical documentation. It means making the system’s purpose, authority, data sources, decision rules, thresholds, evaluation evidence, limitations, responsible officials, vendor relationships, appeal routes, and monitoring results understandable enough for oversight and public accountability.

Explainability should serve public reasons. A person affected by a public decision needs to know what mattered, what can be corrected, what rule or evidence was applied, and who is responsible. Oversight bodies need deeper records: model documentation, validation reports, audit logs, procurement terms, impact assessments, and outcome evaluations.

Transparency should help people understand, challenge, govern, and repair algorithmic decisions.

Back to top ↑

Procurement, Vendors, and Institutional Capacity

Many public algorithmic systems are procured from vendors. Procurement shapes governance before a system is ever deployed. Contract terms can determine whether agencies receive documentation, source access, audit rights, data rights, performance reports, update notices, bias testing, security obligations, appeal support, and termination rights.

Vendor systems can create accountability gaps when agencies cannot explain, audit, modify, or challenge the tools they use. Public institutions should not outsource responsibility simply because they outsource software.

Public agencies remain responsible for algorithmic systems they procure, deploy, and rely upon.

Back to top ↑

Impact Assessment and Public-Sector AI Governance

Public-sector AI governance should include structured review before, during, and after deployment. Impact assessment can identify purpose, legal authority, affected people, data sources, risks, expected benefits, alternatives, human review, appeal pathways, monitoring plans, vendor obligations, and stop rules.

Governance should not be a paperwork ritual. It should have authority to modify, delay, limit, pause, or reject systems. A public algorithmic system that cannot be stopped when it harms people is not responsibly governed.

Governance is real only when review can change what happens.

Back to top ↑

Democratic Legitimacy and Human Judgment

Public algorithms raise democratic questions because they shape how state power is exercised. Some decisions require public justification, political accountability, judicial review, administrative procedure, or participatory legitimacy. Technical optimization cannot substitute for democratic authority.

Human judgment matters in public governance, but it must be meaningful. A human reviewer who lacks time, authority, evidence, or independence may simply ratify algorithmic outputs. Meaningful judgment requires trained staff, documented reasons, override authority, escalation pathways, and protection against rubber-stamping.

Public algorithmic systems must remain subordinate to democratic institutions and accountable judgment.

Back to top ↑

Representation Risk

Representation risk appears when public algorithms present administrative categories, risk scores, fraud flags, service priorities, or eligibility outcomes as neutral facts. These outputs often reflect policy choices, data histories, institutional incentives, and contested definitions.

A public algorithm may represent a person as a risk, a case, a fraud probability, a service burden, a compliance target, or a resource cost. These representations can shape treatment, dignity, and rights. Responsible governance must examine what the system makes visible and what it erases.

Public algorithms should not turn people into unchallengeable administrative abstractions.

Back to top ↑

Back to top ↑

Mathematics, Computation, and Modeling

A simple eligibility rule can be represented as a logical condition:

A public risk score may combine multiple features:

A threshold rule converts a score into administrative action:

A public value function can include multiple decision criteria:

These formulas are useful only when rules, features, weights, thresholds, values, and harms are documented, contestable, and accountable.

Back to top ↑

Python Workflow: Public Policy Algorithm Audit

The Python workflow below creates a dependency-light audit for algorithms in public policy and governance. It simulates public algorithmic use cases, scores rights impact, due-process readiness, transparency, human review, data quality, vendor accountability, governance readiness, and action recommendation, then writes reproducible CSV and JSON outputs.

# algorithms_in_public_policy_and_governance_audit.py
from __future__ import annotations

from dataclasses import asdict, dataclass
from pathlib import Path
from statistics import mean
import csv
import json
from datetime import datetime, timezone

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


@dataclass(frozen=True)
class PublicGovernanceConfig:
    article: str = "algorithms_in_public_policy_and_governance"
    high_rights_impact_threshold: float = 0.80
    low_due_process_threshold: float = 0.65
    low_governance_threshold: float = 0.65


def timestamp_utc() -> str:
    return datetime.now(timezone.utc).isoformat()


def write_csv(path: Path, rows: list[dict[str, object]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    if not rows:
        path.write_text("", encoding="utf-8")
        return
    fieldnames = sorted({key for row in rows for key in row.keys()})
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=fieldnames, extrasaction="ignore")
        writer.writeheader()
        writer.writerows(rows)


def write_json(path: Path, payload: object) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(payload, indent=2, sort_keys=True), encoding="utf-8")


def public_algorithm_use_cases() -> list[dict[str, object]]:
    return [
        {"use_case_id": "benefits_eligibility_screening", "rights_impact": 0.94, "due_process": 0.58, "transparency": 0.52, "human_review": 0.60, "data_quality": 0.66, "vendor_accountability": 0.48, "appeal_readiness": 0.54, "monitoring": 0.56, "public_value": 0.70},
        {"use_case_id": "restaurant_inspection_targeting", "rights_impact": 0.54, "due_process": 0.70, "transparency": 0.68, "human_review": 0.72, "data_quality": 0.76, "vendor_accountability": 0.74, "appeal_readiness": 0.62, "monitoring": 0.78, "public_value": 0.84},
        {"use_case_id": "fraud_anomaly_flagging", "rights_impact": 0.86, "due_process": 0.50, "transparency": 0.46, "human_review": 0.58, "data_quality": 0.60, "vendor_accountability": 0.44, "appeal_readiness": 0.42, "monitoring": 0.52, "public_value": 0.62},
        {"use_case_id": "emergency_resource_allocation", "rights_impact": 0.78, "due_process": 0.72, "transparency": 0.74, "human_review": 0.80, "data_quality": 0.78, "vendor_accountability": 0.70, "appeal_readiness": 0.66, "monitoring": 0.82, "public_value": 0.90},
    ]


def score_use_case(row: dict[str, object], config: PublicGovernanceConfig) -> dict[str, object]:
    procedural_readiness = mean([
        float(row["due_process"]),
        float(row["transparency"]),
        float(row["human_review"]),
        float(row["appeal_readiness"]),
    ])
    governance_readiness = mean([
        float(row["data_quality"]),
        float(row["vendor_accountability"]),
        float(row["monitoring"]),
        procedural_readiness,
    ])
    public_algorithmic_risk = float(row["rights_impact"]) * (1.0 - governance_readiness)

    recommendation = "proceed_with_governed_support"
    if float(row["rights_impact"]) >= config.high_rights_impact_threshold and procedural_readiness < config.low_due_process_threshold:
        recommendation = "do_not_deploy_without_due_process_redesign"
    elif governance_readiness < config.low_governance_threshold:
        recommendation = "governance_review_required"
    elif float(row["rights_impact"]) >= config.high_rights_impact_threshold:
        recommendation = "deploy_only_with_independent_oversight"
    elif float(row["public_value"]) < 0.60:
        recommendation = "reassess_public_value"

    return {
        "use_case_id": row["use_case_id"],
        "rights_impact": round(float(row["rights_impact"]), 6),
        "due_process": round(float(row["due_process"]), 6),
        "transparency": round(float(row["transparency"]), 6),
        "human_review": round(float(row["human_review"]), 6),
        "data_quality": round(float(row["data_quality"]), 6),
        "vendor_accountability": round(float(row["vendor_accountability"]), 6),
        "appeal_readiness": round(float(row["appeal_readiness"]), 6),
        "monitoring": round(float(row["monitoring"]), 6),
        "public_value": round(float(row["public_value"]), 6),
        "procedural_readiness_score": round(procedural_readiness, 6),
        "governance_readiness_score": round(governance_readiness, 6),
        "public_algorithmic_risk_score": round(public_algorithmic_risk, 6),
        "recommendation": recommendation,
    }


def governance_register() -> list[dict[str, str]]:
    return [
        {"control": "algorithm_inventory", "review_question": "Is the system listed with purpose, owner, vendor, data, and decision role?", "status": "required"},
        {"control": "legal_authority_review", "review_question": "Is there lawful authority for this use and decision role?", "status": "required"},
        {"control": "impact_assessment", "review_question": "Have rights, equity, public value, alternatives, and risks been reviewed?", "status": "required"},
        {"control": "due_process_plan", "review_question": "Are notice, reasons, correction, appeal, and remedy available?", "status": "required"},
        {"control": "vendor_accountability", "review_question": "Do contracts provide documentation, audit rights, update controls, and exit options?", "status": "required"},
        {"control": "monitoring_and_audit", "review_question": "Are performance, errors, drift, reliance, appeals, and harms monitored?", "status": "required"},
        {"control": "stop_rule", "review_question": "Can the system be paused, limited, rolled back, or retired?", "status": "required"},
    ]


def main() -> None:
    config = PublicGovernanceConfig()
    use_cases = public_algorithm_use_cases()
    audit = [score_use_case(row, config) for row in use_cases]
    controls = governance_register()

    summary = {
        "article": config.article,
        "timestamp_utc": timestamp_utc(),
        "use_cases_reviewed": len(audit),
        "use_cases_not_ready_for_deployment": sum(1 for row in audit if row["recommendation"] == "do_not_deploy_without_due_process_redesign"),
        "use_cases_requiring_governance_review": sum(1 for row in audit if row["recommendation"] == "governance_review_required"),
        "use_cases_requiring_independent_oversight": sum(1 for row in audit if row["recommendation"] == "deploy_only_with_independent_oversight"),
        "mean_procedural_readiness_score": round(mean(float(row["procedural_readiness_score"]) for row in audit), 6),
        "mean_governance_readiness_score": round(mean(float(row["governance_readiness_score"]) for row in audit), 6),
        "mean_public_algorithmic_risk_score": round(mean(float(row["public_algorithmic_risk_score"]) for row in audit), 6),
        "governance_controls": len(controls),
        "interpretation": "Public algorithmic governance should connect rights impact, due process, transparency, human review, data quality, vendor accountability, appeals, monitoring, public value, and stop authority.",
    }

    write_csv(TABLES / "public_algorithm_use_cases.csv", use_cases)
    write_csv(TABLES / "public_governance_audit.csv", audit)
    write_csv(TABLES / "public_governance_register.csv", controls)
    write_csv(TABLES / "public_governance_summary.csv", [summary])

    write_json(JSON_DIR / "public_governance_config.json", asdict(config))
    write_json(JSON_DIR / "public_governance_audit.json", audit)
    write_json(JSON_DIR / "public_governance_register.json", controls)
    write_json(JSON_DIR / "public_governance_summary.json", summary)

    print("Algorithms in public policy and governance audit complete.")
    print(TABLES / "public_governance_summary.csv")


if __name__ == "__main__":
    main()

This workflow turns public algorithmic governance into a reproducible review artifact: rights impact, due process, transparency, human review, data quality, vendor accountability, appeal readiness, monitoring, public value, governance readiness, and deployment recommendation are documented together.

Back to top ↑

R Workflow: Public Governance Diagnostics

The R workflow reads the generated CSV outputs, summarizes procedural readiness and governance risk, visualizes public-sector algorithmic review components, and writes an additional diagnostic table.

# algorithms_in_public_policy_and_governance_summary.R
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()
}

setwd(article_root)

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)

audit_path <- file.path(tables_dir, "public_governance_audit.csv")
summary_path <- file.path(tables_dir, "public_governance_summary.csv")

if (!file.exists(audit_path)) {
  stop(paste("Missing", audit_path, "Run the Python workflow first."))
}

audit <- read.csv(audit_path, stringsAsFactors = FALSE)
summary <- read.csv(summary_path, stringsAsFactors = FALSE)

png(file.path(figures_dir, "public_governance_readiness.png"), width = 1200, height = 850)
score_matrix <- t(as.matrix(audit[, c("rights_impact", "procedural_readiness_score", "governance_readiness_score", "public_value")]))
barplot(score_matrix,
        beside = TRUE,
        names.arg = audit$use_case_id,
        las = 2,
        ylim = c(0, 1),
        ylab = "Score",
        main = "Algorithms in Public Policy and Governance: Rights, Readiness, and Public Value")
legend("bottomright",
       legend = rownames(score_matrix),
       cex = 0.72,
       bty = "n")
grid()
dev.off()

png(file.path(figures_dir, "public_algorithmic_risk.png"), width = 1000, height = 750)
barplot(audit$public_algorithmic_risk_score,
        names.arg = audit$use_case_id,
        las = 2,
        ylab = "Public Algorithmic Risk Score",
        main = "Public Algorithmic Risk by Use Case")
grid()
dev.off()

r_summary <- data.frame(
  use_cases_reviewed = summary$use_cases_reviewed[1],
  use_cases_not_ready_for_deployment = summary$use_cases_not_ready_for_deployment[1],
  use_cases_requiring_governance_review = summary$use_cases_requiring_governance_review[1],
  use_cases_requiring_independent_oversight = summary$use_cases_requiring_independent_oversight[1],
  mean_procedural_readiness_score = summary$mean_procedural_readiness_score[1],
  mean_governance_readiness_score = summary$mean_governance_readiness_score[1],
  mean_public_algorithmic_risk_score = summary$mean_public_algorithmic_risk_score[1],
  governance_controls = summary$governance_controls[1],
  diagnostic_note = "Public algorithmic governance should connect rights impact, due process, transparency, human review, data quality, vendor accountability, appeals, monitoring, public value, and stop authority."
)

write.csv(r_summary, file.path(tables_dir, "r_public_governance_diagnostic_summary.csv"), row.names = FALSE)
print(r_summary)

The R layer turns procedural readiness, governance readiness, rights impact, public value, and public algorithmic risk into visible diagnostic summaries that support impact assessment, oversight, appeal design, and accountable public-sector deployment.

Back to top ↑

GitHub Repository

The companion repository contains reproducible workflows, synthetic data, audit outputs, calculators, documentation, and multilingual examples for this article.

Back to top ↑

A Practical Method for Public Algorithmic Governance

Public algorithmic governance should begin with public purpose, legal authority, affected people, and institutional responsibility before model selection. The central question is not “Can this decision be automated?” but “Should this public power be structured this way, under what authority, with what protections, and with what accountability?”

This method treats public algorithms as exercises of administrative power, not merely decision tools.

Back to top ↑

Common Pitfalls

Algorithms in public policy and governance can fail when institutions confuse efficiency with fairness, prediction with proof, vendor software with public authority, or human review with accountability.

Public algorithms should make government more accountable, not harder to challenge.

Back to top ↑

Why Public Algorithms Require Democratic Accountability

Algorithms in public policy and governance show that computational reasoning can improve administrative capacity, consistency, targeting, planning, and service delivery. But public-sector algorithms also shape the exercise of public power. They influence who receives support, who is scrutinized, who waits, who is denied, who is investigated, and who can challenge a decision.

Responsible public algorithmic systems must be lawful, explainable, contestable, auditable, monitored, and subordinate to accountable institutions. They require due process, appeal, data correction, human judgment, public reporting, procurement safeguards, impact assessment, and stop authority.

The central standard is not whether a system is efficient or accurate in isolation. It is whether the system supports legitimate public governance. In democratic institutions, algorithms may assist administration, but they must not replace public responsibility. AI belongs in the toolkit, not in control.

Back to top ↑

Related Articles

• Algorithms in Knowledge Architecture
• Algorithms in Media Platforms and Attention Systems
• Contestability, Appeals, and Algorithmic Due Process
• Algorithmic Accountability and Audit Trails
• Algorithmic Risk Management and AI Governance

Back to top ↑

Further Reading

• Eubanks, V. (2018) Automating Inequality: How High-Tech Tools Profile, Police, and Punish the Poor. New York: St. Martin’s Press.
• Citron, D.K. (2008) ‘Technological due process’, Washington University Law Review, 85(6), pp. 1249–1313.
• Pasquale, F. (2015) The Black Box Society: The Secret Algorithms That Control Money and Information. Cambridge, MA: Harvard University Press.
• Richardson, R., Schultz, J.M. and Crawford, K. (2019) ‘Dirty data, bad predictions: How civil rights violations impact police data, predictive policing systems, and justice’, New York University Law Review Online, 94, pp. 192–233.
• Selbst, A.D. et al. (2019) ‘Fairness and abstraction in sociotechnical systems’, Proceedings of the Conference on Fairness, Accountability, and Transparency, pp. 59–68.
• AI Now Institute (2018) Algorithmic Impact Assessments: A Practical Framework for Public Agency Accountability.
• National Institute of Standards and Technology (2023) Artificial Intelligence Risk Management Framework. Gaithersburg, MD: NIST.

Back to top ↑

References

• AI Now Institute (2018) Algorithmic Impact Assessments: A Practical Framework for Public Agency Accountability. Available at: https://ainowinstitute.org/publication/algorithmic-impact-assessments-a-practical-framework-for-public-agency-accountability.
• Citron, D.K. (2008) ‘Technological due process’, Washington University Law Review, 85(6), pp. 1249–1313.
• Eubanks, V. (2018) Automating Inequality: How High-Tech Tools Profile, Police, and Punish the Poor. New York: St. Martin’s Press.
• National Institute of Standards and Technology (2023) Artificial Intelligence Risk Management Framework. Gaithersburg, MD: NIST. Available at: https://www.nist.gov/itl/ai-risk-management-framework.
• Pasquale, F. (2015) The Black Box Society: The Secret Algorithms That Control Money and Information. Cambridge, MA: Harvard University Press.
• Richardson, R., Schultz, J.M. and Crawford, K. (2019) ‘Dirty data, bad predictions: How civil rights violations impact police data, predictive policing systems, and justice’, New York University Law Review Online, 94, pp. 192–233.
• Selbst, A.D., Boyd, D., Friedler, S.A., Venkatasubramanian, S. and Vertesi, J. (2019) ‘Fairness and abstraction in sociotechnical systems’, Proceedings of the Conference on Fairness, Accountability, and Transparency, pp. 59–68.

Back to top ↑