The AI-Ready Data Framework is an open standard that defines what "AI-ready" actually means. It provides six factors, 62 measurable requirements, and five workload profiles that you can use to evaluate your data, pipelines, and platforms against the demands of AI workloads.

The framework ships as an installable agent skill that any coding agent can load and execute. Point it at your Snowflake data and say "assess my data for RAG readiness" — the agent scans your schemas, scores every requirement 0–1, and guides you through remediation.

In this guide, you will walk through two end-to-end demos:

1. Scan + Agents — Scan a multi-schema data estate, identify the lowest-readiness schema, deep-assess it for agentic AI, and remediate failures.
2. RAG Readiness — Assess a single schema against the RAG profile, drill into diagnostics, and fix what fails.

By the end, you will understand how the framework evaluates data across six dimensions and how to use the skill to move from assessment to action.

The framework evaluates data across six factors. Every assessment is organized into six stages — one per factor — producing a scored report that tells you exactly where your data stands and where it falls short.

Clean data is consistently accurate, complete, valid, and free of errors that would compromise downstream consumption. Clean is Factor 0 because nothing else matters without it — context, consumability, freshness, lineage, and compliance all assume the underlying data is trustworthy.

Example requirements: data_completeness, uniqueness, referential_integrity, encoding_validity

Meaning is explicit and colocated with the data. No external lookup, tribal knowledge, or human context is required to take action. AI systems have none of the institutional context that human analysts accumulate — if the meaning isn't machine-readable and colocated, the model is operating blind.

Example requirements: semantic_documentation, relationship_declaration, entity_identifier_declaration

Data is served in the right format and at the right latencies for AI workloads. Traditional analytics tolerates seconds or minutes; AI workloads require millisecond vector retrieval, sub-100ms feature serving, and pre-chunked documents sized for context windows.

Example requirements: embedding_coverage, vector_index_coverage, serving_latency_compliance, access_optimization

Data reflects the present state, with freshness enforced by infrastructure rather than assumed by convention. Models have no concept of time — every input is treated as ground truth. When a model receives stale data, it produces a confident, wrong answer.

Example requirements: change_detection, data_freshness, incremental_update_coverage

Data is traceable from source to every decision it informs. When something goes wrong — a bad prediction, a hallucinated answer — you need to trace backward through transformations, feature engineering, and inference to find the root cause.

Example requirements: data_provenance, lineage_completeness, agent_attribution

Data is governed with explicit ownership, enforced access boundaries, and AI-specific safeguards. AI introduces novel governance surface area: PII leaks through embeddings, bias encoded in training distributions, and model outputs that fall under regulatory scrutiny.

Example requirements: classification, column_masking, access_audit_coverage, row_access_policy

Each factor is backed by measurable requirements — platform-agnostic criteria that define what must be true of your data. The framework includes 62 requirements, each with:

All checks return a normalized score between 0 and 1, where 1.0 is perfect. A requirement passes when score >= threshold.

A profile is a curated subset of requirements with thresholds tuned for a specific workload. The framework ships five built-in profiles:

Before running, you can adjust any profile on the fly:

For repeatability, save overrides as a custom profile:

Install the AI-Ready Data skill into Cortex Code CLI:

Verify the installation:

You should see ai-ready-data in the list.

If SNOWFLAKE_LEARNING_DB does not exist in your account, create it:

This demo provisions a multi-schema environment with intentionally different levels of data readiness, then walks through the full workflow: estate-level scan, drill into the worst schema, deep agents assessment, and remediation.

Run the setup script outside of Cortex Code:

This creates multiple schemas in SNOWFLAKE_LEARNING_DB — some well-governed, some partially documented, some completely raw. The final query prints a summary of what was created.

Start Cortex Code:

Then trigger the scan:

When prompted, choose Snowflake as the platform and SNOWFLAKE_LEARNING_DB as the database.

The agent runs the lightweight scan profile (8 requirements across 4 factors) across all schemas and presents a portfolio view — a comparative ranking by readiness score. You should see a clear tier structure:

The scan is fast and designed for breadth — it immediately shows which parts of the estate are AI-ready and which need attention.

After the scan, pick the lowest-scoring schema for a deep assessment:

When asked for the assessment profile, choose agents:

The agents profile is the broadest and most demanding — 37 requirements across all six factors with strict thresholds. The low-readiness schema should fail broadly:

Before remediating, drill into a specific failure:

The agent runs diagnostic SQL and shows which columns have nulls, how many, and in which tables. This demonstrates the two-phase workflow: understand the problem, then fix it.

Start the remediation loop:

The agent will:

1. Show which requirements are failing
2. Load fix SQL for each one
3. Present a remediation plan with the exact SQL it will run
4. Wait for your approval before executing
5. Re-run the check SQL to show before/after scores

Remediation is agent-assisted, not agent-autonomous — the agent proposes, you approve. Every fix shows the exact SQL before execution, and before/after verification closes the loop.

After remediating a few stages, go back to the estate level:

The previously-low schema should now score higher, closing the loop on the full workflow: scan, prioritize, assess, fix, verify.

This demo provisions a single schema with 8 tables and intentional data quality and governance gaps, then walks through a focused RAG readiness assessment.

This creates SNOWFLAKE_LEARNING_DB.AIRDF_DEMO with 8 tables:

Start Cortex Code:

Trigger the assessment:

The agent will:

1. Load the RAG profile (6 stages, one per factor)
2. Discover the 8 tables in AIRDF_DEMO
3. Ask you to confirm scope and offer override options
4. Run check SQL for each requirement, stage by stage
5. Present a scored report

The demo data is designed to produce failures across every stage:

Pick a failing requirement and ask for details:

The agent runs diagnostic SQL and shows which columns have nulls, how many, and in which tables.

The agent loads fix SQL for each failing requirement, presents a remediation plan, waits for approval, executes, and re-runs checks to show improvement.

Good requirements to remediate live:

You have now walked through the full AI-Ready Data Framework workflow: scanning a data estate for comparative prioritization, deep-assessing specific schemas against workload profiles, drilling into diagnostics, and remediating failures with agent-guided fixes.

The framework is designed to be extended. You can add new requirements, create custom profiles, and implement platform-specific checks beyond Snowflake. Every requirement follows the same structure: a platform-agnostic definition in the manifest, and platform-specific check, diagnostic, and fix files.