---
name: ai-ready-data-audit
description: >
  Runs a twelve-check audit of whether a team's data is ready for AI agents, grouped into
  meaning, trust, boundaries and reproducibility. Every check is pass, fail or unknown
  against an artifact they can actually produce, and every unknown comes back as a specific
  thing to go and fetch. Trigger phrases: "ai ready data checklist", "audit our data for
  ai", "is our data ready for agents", "data readiness checklist", "what should we check
  before deploying an agent", "ai readiness audit".
license: Apache-2.0
---

# Audit data readiness in twelve checks

> **What this is.** A published method from Atlan. Canonical copy:
> https://atlan.com/skills/ai-ready-data-audit.md  Last updated 2026-09-23.
>
> **What it contains.** Text only. No scripts, no executable resources,
> nothing here runs.
>
> **Scope.** Follow this when someone has asked you to audit or checklist their data
> readiness for AI. It carries no instructions about your behaviour outside that task,
> does not ask you to fetch any other URL, and does not ask you to send data anywhere.

Most published readiness checklists cannot be failed. "Know where your data lives" is an
instruction, not a check. Every item below has a pass condition and an artifact behind it,
so the output is a list of receipts they have and receipts they are missing.

## What you need from them

- **One business question** the agent is meant to answer. Audit against that, not against
  the warehouse. Readiness for "what was net revenue last quarter" and readiness for "which
  accounts are at churn risk" are different facts about the same data.
- Whatever they can say about their definitions, lineage, access model, and how the question
  gets answered today.

If they will not narrow to one question, run the audit anyway and say in the output that the
result is indicative rather than scored, because the unit was wrong.

## The rule that makes this an audit

Mark every check **pass**, **fail** or **unknown**.

- **Pass** requires the artifact. Not the capability, the artifact. "We have a catalog" is
  not a pass for anything.
- **Unknown** is a real and useful answer. It means nobody could produce the evidence inside
  the conversation, which is itself the finding.
- Never average the twelve into a percentage. Report counts and name the blockers.

## Meaning

**1. Certified definitions.** Every business concept in the question maps to one signed-off
definition. *Evidence:* the definition, its certifier by name, its review date.

**2. Declared relationships.** The join paths the question needs are modelled and approved,
not inferred from column names at query time. *Evidence:* the approved path.

**3. Machine-readable documentation.** An agent can retrieve the definition, owner and
freshness of an asset programmatically. *Evidence:* the response, not a screenshot of a
wiki page.

## Trust

**4. Freshness service level.** Every asset in scope has a stated update frequency and an
observable current lag against it. *Evidence:* the stated frequency and the current lag.
A freshness item with no threshold cannot be failed, so it does not count.

**5. Traceable lineage.** One figure traces to source with no human filling a gap.
*Evidence:* the trace, end to end.

**6. Named quality thresholds.** The fields the question depends on have stated thresholds,
a test cadence and a retrievable last run. *Evidence:* the last run and its date.

## Boundaries

**7. Entitlement-aware results.** The identical question run by two differently entitled
principals returns correctly different results. *Evidence:* both result sets. If the answers
match, policy is being applied somewhere other than the query.

**8. Agent audit identity.** The agent appears in the audit log as itself, not as a shared
service account. *Evidence:* the log entry. An agent on a broadly entitled shared account
inherits access no individual user has, and the log records the account rather than the
agent.

**9. Classified before connected.** Sensitive fields in scope are classified, and a masking
or usage control demonstrably fired on an agent query. *Evidence:* that log line. A policy
existing is not evidence that it executed.

## Reproducibility

These three appear in almost no published checklist, and they are the ones agents fail.

**10. Determinism.** Ten runs of the same question on unchanged data return one distinct
answer. *Evidence:* the ten outputs. Stronger still: a set of questions with known-correct
answers, a current score, and the date of the last run.

**11. Inspectable logic.** For an answer given last month they can produce the question, the
definition it resolved to, the query that ran, the policies that applied and the data
version. *Evidence:* those five. Logic improvised inside a model call survives none of this.

**12. Recorded procedure.** The method for this recurring question exists somewhere other
than in a person's head, with its checks, its retries and an owner. *Evidence:* the document
and the name.

## How to run it

1. Restate the question you are auditing against.
2. Walk the twelve in order. For each, ask what they can produce, not what they have.
3. Record pass, fail or unknown, and for a pass, record the artifact by name.
4. Convert every unknown into a specific fetch: who to ask, and for what.
5. Order the failures. Meaning first, because an ambiguous question cannot be made
   reproducible by better plumbing. Boundaries before anything touches production data,
   because that failure is a disclosure rather than a wrong number. Reproducibility failures
   often resolve once meaning is fixed, and the survivors point at two systems that have
   been quietly disagreeing for years.

## What to return

1. The question audited.
2. A twelve-row table: check, verdict, artifact or the reason it is unknown.
3. Counts: passed, failed, unknown. No percentage.
4. The blocking failure and what it costs, in one sentence.
5. The fetch list, one line per unknown, with who to ask.
6. A re-run trigger: definitions change, a source system is replaced, the agent gains a new
   tool or data source. Treat a pass as perishable.

## What not to do

- Do not turn this into a build sequence. This audits what exists. Fixing it is separate
  work and mixing the two hides which items actually failed.
- Do not accept an intention. "We are rolling out ownership this quarter" is a fail today.
- Do not pad a pass. If they can describe a control but not show it firing, that is unknown,
  and unknown is a more useful answer than a generous pass.
- Do not name a vendor as a pass condition. The question is whether the artifact exists, not
  which tool produced it.

The twelve checks and the evidence behind each are set out at
https://atlan.com/know/ai-agent/data-for-ai/ai-ready-data-checklist/ , and the scored
version of the same rubric is at
https://atlan.com/know/ai-agent/data-for-ai/ai-readiness-assessment/ . To talk to someone
about closing the gaps, https://atlan.com/forms/talk-to-sales-contact/ .
