I10 · Responsible AI in Practice

Model Cards and Datasheets

A model card is a short document that accompanies a trained model, describing its intended use and users, uses it should not be put to, the data it was trained and evaluated on, performance overall and for relevant groups, ethical considerations, limitations and contact details. The idea was proposed by Margaret Mitchell and colleagues in 2019. A datasheet for a data set, proposed by Timnit Gebru and colleagues in 2018, records why the data was collected, by whom, what it contains, how it was collected and labelled, consent and privacy measures, known gaps and recommended uses. Together they make AI systems transparent and accountable.

10 min Intermediate · Sublevel Advanced Jump to the activity

What you need: The earlier topics of this module.

Definition

Medicines come with a leaflet: what they treat, the dose, side effects and who should not take them. AI models and data sets are used for decisions that matter just as much, yet often arrive with no leaflet at all. Model cards and datasheets are that leaflet.

A model card is a short document that accompanies a trained model, describing its intended use and users, uses it should not be put to, the data it was trained and evaluated on, performance overall and for relevant groups, ethical considerations, limitations and contact details. The idea was proposed by Margaret Mitchell and colleagues in 2019. A datasheet for a data set, proposed by Timnit Gebru and colleagues in 2018, records why the data was collected, by whom, what it contains, how it was collected and labelled, consent and privacy measures, known gaps and recommended uses. Together they make AI systems transparent and accountable.

In simple words

A model card is the instruction leaflet for an AI model; a datasheet is the ingredients label for a data set. Anyone about to use them can quickly see what they are for, how well they work and where they might fail.

Overview

  • Model cards and datasheets are short documents that describe a model or dataset honestly.
  • Model cards were proposed by Mitchell et al. (2019); datasheets for datasets by Gebru et al. (2018).
  • They record intended use, performance, limitations and ethical considerations.
  • Performance should be reported for different groups, not only overall.
  • Platforms such as Hugging Face show a model card with every model.
  • Laws such as the EU AI Act require similar technical documentation for high-risk systems.

Why it matters

Models and data sets are shared and reused far beyond their original purpose. Without documentation, people use them in situations they were never tested for, hidden biases spread and no one knows who is responsible. Documentation also helps teams remember their own decisions.

Key terms

Model card
A document describing a model's purpose, performance, limits and ethical considerations.
Datasheet for datasets
A document describing how and why a data set was created and how it should be used.
Intended use
The tasks and users a model was designed and tested for.
Out-of-scope use
Uses the model should not be applied to, because it was not tested or could cause harm.
Disaggregated metrics
Performance reported separately for each relevant group.
Data provenance
Where data came from and how it was processed along the way.

Types

There are several types of AI documentation. Each serves a different reader.

1. Model cards

A short report on a trained model's purpose, performance and limits.

  • How it works: Sections cover model details, intended use, factors, metrics, evaluation data, training data, ethical considerations and caveats.
  • Example: A card stating a skin-lesion model was tested mostly on lighter skin and should not be used alone for diagnosis.
  • When to use it: Write one for every model you share or deploy, including student projects.

2. Datasheets for datasets

A document answering standard questions about a dataset's creation and use.

  • How it works: Questions cover motivation, composition, collection process, preprocessing, uses, distribution and maintenance.
  • Example: A datasheet noting that survey responses came only from people with smartphones.
  • When to use it: Write one whenever you collect or publish a dataset. It warns later users about gaps before they build models on the data.

3. System cards and AI fact sheets

Documentation for a whole AI product, including several models and safeguards.

  • How it works: They describe how components work together, safety testing, red-teaming results and known risks.
  • Example: An LLM provider's system card describing tests for dangerous capabilities and the mitigations added.
  • When to use it: Use them for deployed products where risks come from the whole system, not one model.

4. Data and AI impact assessments

Structured reviews of possible harms before a system is launched.

  • How it works: Teams describe the purpose, affected people, risks to rights and safety, mitigations and who approved the launch.
  • Example: A city assessing a traffic-camera AI for privacy and wrongful-fine risks before installation.
  • When to use it: Use them for high-stakes or public-sector systems; some laws require them.

5. Audit logs and change records

Ongoing records of versions, data changes, decisions and incidents.

  • How it works: Version control, experiment trackers and incident logs let anyone trace what changed and why.
  • Example: Tracing a sudden accuracy drop to a new data source added in a specific release.
  • When to use it: Use them throughout a model's life to support accountability and audits.

Explained in detail

What goes in a model card

SectionExample for a crop-disease classifier
Model detailsMobileNet fine-tuned, version 2.1, built by an agriculture university lab, March 2026
Intended useFirst-level advice to farmers and extension workers on six tomato diseases
Out-of-scopeOther crops; deciding insurance claims; replacing an agronomist
Training data12,000 phone photos from three states, link to datasheet
EvaluationAccuracy 91% overall; 86% on photos from low-cost phones; 79% in early-morning light
Ethical considerations and limitsWeaker for regions not in the data; never use as the only basis for spraying decisions

Model cards are now common: Hugging Face shows a model card on every model page, and major AI companies publish model cards or system cards for their large models, describing evaluations, safety testing and known risks. A good card is honest about weaknesses rather than promotional. The most useful sections are usually the disaggregated metrics, which reveal where performance is weaker, and the out-of-scope uses, which warn people not to stretch the model into situations it was never meant for.

What goes in a datasheet

Gebru and colleagues organised a datasheet as a series of questions. Motivation: why was the data set created and who funded it? Composition: what does each record represent, how many are there, which groups are included, is anything missing, does it contain personal or sensitive data? Collection: how was it gathered, over what time, with what consent? Pre-processing and labelling: what cleaning was done, who labelled it and how were they paid and instructed? Uses: what is it suitable for and what should it not be used for? Distribution and maintenance: under what licence is it shared, who maintains it and how can errors be reported? Answering these questions often reveals problems before anyone trains a model.

  • Keep cards and datasheets versioned alongside the model and data, and update them with every release.
  • Write for the people who will use the model, not only for its builders: plain language, clear warnings.

Documentation is also a design tool, not just paperwork. Filling in the intended-use section early forces a team to agree on who the system is for, which shapes what data to collect and which groups to test. Writing the evaluation section reveals gaps in testing before launch, and the limitations section becomes the basis for warnings shown to users. Teams that write cards only at the end often discover problems too late to fix cheaply.

How it works

  1. Start a datasheet when you begin collecting data, not at the end.
  2. Record intended and out-of-scope uses before training.
  3. Evaluate overall and for each relevant group and condition.
  4. Write the model card honestly, including weaknesses and contact details.
  5. Publish the card with the model and update it with each version.

In code

model_card.py
card = {
    "name": "Tomato leaf disease classifier v2.1",
    "intended_use": "First-level advice to farmers and extension workers on six tomato diseases",
    "out_of_scope": ["other crops", "insurance claim decisions", "replacing an agronomist"],
    "training_data": "12,000 phone photos from Maharashtra, Karnataka and Odisha (see datasheet)",
    "metrics": {"overall": 0.91, "low-cost phones": 0.86, "early-morning light": 0.79, "Odisha photos": 0.84},
    "limitations": "Weaker in poor light and for regions not in the data",
    "contact": "plant-ai-lab@example.edu",
}

def render(card, warn_below=0.85):
    lines = [f"# Model card: {card['name']}", "", f"**Intended use:** {card['intended_use']}",
             "**Do not use for:** " + "; ".join(card["out_of_scope"]),
             f"**Training data:** {card['training_data']}", "", "| Condition | Accuracy |", "|---|---|"]
    for cond, acc in card["metrics"].items():
        flag = "  ⚠ below target" if acc < warn_below else ""
        lines.append(f"| {cond} | {acc:.0%}{flag} |")
    lines += ["", f"**Limitations:** {card['limitations']}", f"**Contact:** {card['contact']}"]
    return "\n".join(lines)

print(render(card))
missing = [k for k in ["intended_use", "out_of_scope", "metrics", "limitations", "contact"] if not card.get(k)]
print("\nMissing sections:", missing or "none")

Output

# Model card: Tomato leaf disease classifier v2.1

**Intended use:** First-level advice to farmers and extension workers on six tomato diseases
**Do not use for:** other crops; insurance claim decisions; replacing an agronomist
**Training data:** 12,000 phone photos from Maharashtra, Karnataka and Odisha (see datasheet)

| Condition | Accuracy |
|---|---|
| overall | 91% |
| low-cost phones | 86% |
| early-morning light | 79%  ⚠ below target |
| Odisha photos | 84%  ⚠ below target |

**Limitations:** Weaker in poor light and for regions not in the data
**Contact:** plant-ai-lab@example.edu

Missing sections: none

Try it yourself

The model used for the wrong job

A face-analysis model trained to estimate age for photo albums is picked up by another company.

Model card or datasheet?

Where does each piece of information belong?

  • Accuracy for each region

  • How the photos were collected and with what consent

  • Who labelled the data and how they were paid

  • Uses the model must not be applied to

Common mistakes

  • Writing documentation that hides weaknesses.
  • Reporting only overall accuracy in the model card.
  • Never updating the card after the model changes.

Check yourself

Question 1

1. Who proposed model cards, and when?

Question 2

2. Which section warns people not to use a model for certain tasks?

Question 3

3. A datasheet mainly documents…

Summary

  • Model cards describe a model's intended use, out-of-scope uses, data, group-level performance and limits.
  • Datasheets describe why and how a data set was made, what it contains, consent, gaps and uses.
  • Honest, updated documentation prevents misuse and supports accountability.

Finished reading?

Sources: Mitchell et al. (2019), Model Cards for Model Reporting · Gebru et al. (2021), Datasheets for Datasets, Communications of the ACM