An Enterprise AI Maturity Model You Can Actually Use

Vendor maturity frameworks score your cloud spend and leave your portfolio unchanged. A useful enterprise AI maturity model answers a narrower question: what should we build next quarter — and what will waste money if we build it too early? Assess readiness across people, process, data, and operating model. Use the score to sequence capability building, not to win a benchmark press release.

Dimensions that actually predict outcomes#

Four dimensions cover most production failures. Skip any one and the model lies.

Level 5 everywhere is fantasy. Goal is minimum viable maturity per job class — not uniform excellence.

Building the assessment rubric#

Start from failures you have seen, not from a consultant's generic slide:

1. List last year's stalled initiatives and prod incidents
2. Tag root cause: people, process, data, operating model
3. Turn recurring tags into observable criteria (yes/no or 0–2)
4. Weight dimensions by risk appetite — regulated write paths weigh process heavier

from dataclasses import dataclass, field
from enum import IntEnum

class Level(IntEnum):
    AD_HOC = 1
    REPEATABLE = 2
    DEFINED = 3
    MANAGED = 4
    OPTIMIZED = 5

@dataclass
class DimensionScore:
    people: Level
    process: Level
    data: Level
    operating_model: Level

    def weakest(self) -> str:
        pairs = {
            "people": int(self.people),
            "process": int(self.process),
            "data": int(self.data),
            "operating_model": int(self.operating_model),
        }
        return min(pairs, key=pairs.get)

@dataclass
class JobClassAssessment:
    name: str
    scores: DimensionScore
    target_autonomy_tier: int  # 0 read .. 3 bounded auto

    def blockers(self) -> list[str]:
        blockers: list[str] = []
        s = self.scores
        if self.target_autonomy_tier >= 2 and int(s.process) < 3:
            blockers.append("Raise process to DEFINED before write autonomy")
        if int(s.data) < 2:
            blockers.append("Establish job-class data contract")
        if int(s.operating_model) < 3:
            blockers.append("Ship gateway + eval regression on rails")
        if int(s.people) < 2:
            blockers.append("Name prod engineering owner")
        return blockers

assessment = JobClassAssessment(
    name="Contract clause extract",
    scores=DimensionScore(
        people=Level.DEFINED,
        process=Level.REPEATABLE,
        data=Level.DEFINED,
        operating_model=Level.DEFINED,
    ),
    target_autonomy_tier=2,
)

for b in assessment.blockers():
    print(b)

Run assessments with domain leads and platform — not as self-graded checkbox theater.

Sequencing investments from scores#

Use weakest dimension to pick the next quarter's work:

Chasing Level 5 models at Level 1 operating model repeats pilot graveyards.

Maturity without bureaucracy#

Keep the model lightweight:

• Quarterly refresh — 90-minute review per major job class
• Evidence-based — link to prod dashboards, eval trends, incident IDs
• Public internally — scores visible to steering; no surprise audits
• Action-tied — each low score maps to one funded initiative, not a task force

Example criteria by dimension#

Use these as a starting checklist — not a mandatory scorecard. Adapt to your job classes and risk appetite.

Using maturity for executive narrative#

Steering committees want progress without fiction. Report:

• Job classes with level movement (e.g., process 2→3)
• Blockers removed and workflows unlocked
• Initiatives delayed because maturity gap — with funded fix

Do not report average maturity score alone. Averages hide stagnation in high-risk classes.

Common mistakes#

• Copy external framework verbatim — ignores your job classes and risk appetite
• Self-assessment without evidence — everyone is Level 3 on paper
• Maturity as gatekeeping weapon — CoE blocking domains indefinitely
• Ignoring people dimension — perfect gateway, no owner, still stalls
• One enterprise score — masks ready search vs not-ready trading agent

Connecting maturity to funding gates#

Transparent gates reduce politics. Domains know what to build to unlock budget instead of lobbying for exceptions.

Summary#

An enterprise AI maturity model is a diagnostic for sequencing capability building across people, process, data, and operating model — scored per job class, refreshed quarterly, tied to evidence and funded actions. Use weakest-dimension analysis to pick next quarter's investments and to delay autonomy or portfolio expansion when gaps predict incident or stall. The point is not a high maturity number. It is knowing what to build next so production workflows compound instead of pilots accumulating.