How I think about
data & AI at scale.

Strategy & value

Enterprises rarely need a parallel AI organization sitting beside the business. They need a small capability that makes every existing team measurably faster at what it already does. The test for any initiative: does it make an existing team's job easier, or does it add one more layer to manage?

The flywheel worth starting

• Trusted data Owned domains with measured quality.
• Reusable data products and context Defined once, used by every team.
• Shared AI platform Gateway, evaluation, agents and paved paths.
• Better employee and customer experiences Answers inside the tools people already use.
• Faster decisions and innovation Cycle time, quality and cost move.
• More value, learning and adoption Which feeds richer data back into the loop.

How I choose what goes first

A portfolio is a sequencing problem, not a wish list. The first capabilities set precedent, so they need to be the ones most likely to succeed and most likely to build the shared foundations everything else depends on. I score candidates on four filters.

• High volume Enough repetitions a year that a small per-transaction gain compounds into something worth the engineering.
• Document-bound The work is reading, extracting and deciding from text and records, which is where current models are strongest.
• Rules exist There is a policy, playbook or standard to point to, so correctness can be checked rather than debated.
• Reversible A wrong output is caught and corrected cheaply. Irreversible processes wait until the platform has a track record.

Alongside those near-term wins I always hold one bet on the core learning problem: a model inside the physical or scientific loop that removes cycles altogether. That is where the largest value usually sits.

The value case: what counts and what does not

One inflated benefit claim that fails an audit costs more credibility than three honest quarters earn. A smaller verified number is worth more than a larger arguable one.

Data foundation

Most AI disappointment traces back to data, not models. So no model work starts until the data it depends on is owned, defined and measured.

Ownership with names attached

• Owner A business leader accountable for the domain's data and for hitting its quality targets.
• Steward Owns definitions, business rules and the glossary for the domain.
• Custodian Owns the pipelines, access controls and operational health of the data.

One pipeline, three layers of trust

• Sources ERP, MES, CRM, PLM, historians, documents and sensors.
• Bronze Raw ingest, immutable and replayable.
• Silver Cleansed and conformed against the quality framework.
• Gold Curated data products with owners and contracts.
• Catalog & lineage Meaning is looked up, not inferred, from source column to decision.
• Agents & decisions Analytics, models and agents consume Gold through the context layer.

Quality you can see

I track coverage in two directions: whether a standard exists for a domain, and whether it is actually in use at every site and system. "We have a standard" and "the standard is used everywhere" are different claims, and federation succeeds or fails on the second.

For a public account of this kind of journey, MIT CISR's case study follows how Caterpillar built a single, trusted data source and the adoption behind it. Wixom, Rodriguez, Piccoli and Beath, “Caterpillar's Digital Data Journey,” MIT CISR Working Paper No. 467 (2025) ↗

No model before the data is ready

Every use case earns a data readiness score, technical and business, before development starts.

Data quality is also an economics lever. Once meaning is looked up rather than inferred, every downstream model call spends fewer tokens working out what the data means.

Context & knowledge

The context layer is where a company's advantage actually lives. Models change every few months; decades of operating records, designs, procedures and expert know-how do not.

• A semantic layer Business definitions fixed once, so "yield", "on-time" or "active customer" mean one thing to every person and every agent.
• Retrieval beyond vectors Vector, graph and structured retrieval together. Many enterprise questions are relational, and graphs are the natural shape for lineage, networks and dependencies.
• Entitlements inherited from source An agent can never surface data the requesting person could not open directly. Permissions travel with the data.
• Lineage and provenance Every answer traces to the record that produced it, which is also how AI-assisted work earns a defensible audit trail.

Three levels of return

• Level 1 · Productivity Specifications, procedures, design rules and quality records become discoverable and reusable.
• Level 2 · Innovation speed New projects start from approved context, data products and components instead of rebuilding them.
• Level 3 · New products Trusted context can eventually power customer-facing services. A strategic option, validated before it is committed.

Tacit knowledge deserves its own program. In plants and labs the most valuable know-how lives in experienced people. Capturing it as structured guidance, with their names on it, both protects the company and gives those experts the recognition they rarely get.

AI platform

Seven layers, each with one owner and one reason to exist. A layer belongs in the center only if doing it once, identically, is clearly better than doing it many times in context.

• L7 · Domain solutions Built by domain teams on the paved path. Use-case selection, workflow redesign and domain evaluation criteria stay close to the work. Owner: Federated
• L6 · Golden paths Scaffolds, SDKs, reference apps, release gates and templates for each authority tier. This is the product the platform team actually sells. Owner: Central
• L5 · Evaluation & observability Golden datasets, regression gates, tracing, drift watch and continuous production sampling. Owner: Central, non-negotiable
• L4 · Agent runtime & orchestration Tool registry, planning and memory, human-in-the-loop checkpoints, rollback and a tested kill switch. Owner: Central
• L3 · Model gateway One path to every model: routing and fallback, caching, policy and PII filters, cost attribution per team. Owner: Central, mandatory
• L2 · Context Semantic layer, vector, graph and structured retrieval, inherited entitlements, lineage. The moat. Owner: Central standards, domain-curated
• L1 · Data estate Operational, engineering, commercial and enterprise data, delivered as governed data products. Owner: Domains, contracted to the platform
• Model lifecycle Training, registry, locked production versions and drift monitoring tied to change control.
• Identity, audit & security Who did what and when, keys, sensitive-data discovery and posture, applied the same way at every layer.

Governance spans every layer rather than sitting as a gate at the end. Cybersecurity, enterprise architecture, legal and finance are partners in the design, not reviewers of the result.

• Systems of record stay put Operational, quality, planning and finance systems remain the record. AI reads from them and writes back only through approved workflows.
• Portable by choice Open table formats, standard model packaging, OpenTelemetry traces and MCP tools keep each layer movable between clouds and data platforms.
• Accelerated where it pays GPU-accelerated simulation and optimization for digital twins, routing and scheduling, used where the speed-up changes a decision rather than everywhere.

The gateway is the control point

• Control Policy enforcement, PII and trade-secret filters, logging, data-residency routing and per-request identity. One place to change a rule and one place to prove it was applied.
• Economics Cost attributed to the requesting team on every call, routing by task class, semantic caching and budget alerts. Finance sees a real bill by domain.
• Optionality Provider abstraction, so a workload can move between model vendors or clouds as prices and terms change. Negotiating leverage becomes a design property.

Retrofitting a gateway after eighteen months of direct model calls is a year of painful work. A gateway that only routes, logs and attributes cost is worth more in month two than a complete platform in month nine, because it starts producing the usage data that tells you what to build next.

The golden path, end to end

• Intake · 1 week A one-page business case: the workflow, the decision changed, the baseline, the named owner, the authority tier and the data. No production owner, no start.
• Scaffold · day one A repository that already works, with gateway auth, approved retrieval, tracing, an evaluation stub and CI. The first commit is domain logic.
• Evaluate · continuous No golden dataset, no promotion. Domains write the criteria; the platform runs the harness and regression gates on every change.
• Review · 3 days One parallel review of security, privacy, responsible AI and architecture against a published checklist scaled to the tier.
• Deploy Production means operated: a named owner, on-call, dashboards for quality, latency and cost, and a documented rollback.
• Measure · 30/90/180 days The intake baseline is re-measured with Finance. Capabilities that miss their threshold are fixed or retired.

The commitment I publish: intake decisions in five working days, a scaffold the day a use case is approved, combined review in three days for lower tiers. A central function that is slow and mandatory is worse than none, so if we miss, domains get a documented exception path.

Physical AI and digital twins

For operations-heavy businesses the platform extends into simulation. A physics-grounded digital twin of a plant, line or fleet becomes a place to test schedules, layouts and maintenance strategies before touching the real world, and a conversational layer lets planners query it in plain language. Physics stays in the loop: thermal limits, capacity constraints and degradation curves bound what a model may say, and hybrid physics-ML beats either alone when failure data is thin.

The cost of a first twin has also collapsed. It no longer has to start as a CAD-first project: existing video, a world model and open standards can stand up a usable facility twin in days, with the sensor layer designed and priced before anything is installed. Keeping OpenUSD as the only contract between capture, data and rendering means each layer can be swapped without rebuilding the rest.

As a worked example, I built a twin of a representative food bank from a public news video in seven days, with the data layer on AWS, rendering in NVIDIA Omniverse, and the cloud architecture and full cost published alongside the code. Mohapatra, “From Video to Digital Twin: Accelerating Spatial Twins with World Models and NVIDIA Omniverse” (2026): paper, code and live twin ↗

Agentic systems

Autonomy is not a property of the technology. It is a permission granted per workflow, set by two questions: how reversible is the action, and how expensive is a wrong one?

• T1 · Assist Reversible · low cost of error May: Retrieve, summarize, draft and explain. Output goes to a person who decides what to do with it. Control: The human is the actor. The agent never writes anywhere. Evidence to launch: Golden dataset, citation to source on every claim, light security review, usage telemetry.
• T2 · Propose Reversible · moderate cost May: Prepare a complete action, such as a plan change, a case response or a document, and stage it for approval. Control: Explicit human approval before anything commits, logged with the reasoning shown. Evidence to launch: Everything in T1, plus approval and override rates and a review of what humans corrected.
• T3 · Act within bounds Reversible · high volume May: Execute inside declared limits on value, scope and time. Escalate anything outside them. Control: Bounds enforced in the runtime, not the prompt. Kill switch and one-step rollback are mandatory. Evidence to launch: Everything in T2, plus shadow mode until agreement with humans clears a threshold, a full audit trail and sampled human review.
• T4 · Operate Hard to reverse · high consequence May: Own a recurring process end to end and report by exception. Control: A named executive is accountable. Dual control on irreversible steps. Formal change management. Evidence to launch: Sustained T3 performance, a documented failure-mode analysis, and sign-off from the business owner, legal and cybersecurity.

The rules that make tiers real

• The tier is declared at intake and enforced by the runtime, not asserted in a design document.
• Tiers are earned, not assigned. Nothing launches above T2, and promotion requires evidence from live operation.
• Every agent has one named human owner who is accountable for its behavior and reachable when it misbehaves.
• Anything touching regulatory submissions, safety, product release or contractual commitments stays at T2 by default, however good the model gets.
• The kill switch is tested. An untested rollback is not a rollback.

Four patterns worth standardizing

• Grounded answer Retrieve, ground, answer, cite. The workhorse. Measure retrieval quality, not just the answer.
• Structured extraction Document to schema with confidence scores and a human queue for low-confidence fields. The highest near-term return in most enterprises.
• Tool-using workflow Plan, call registered tools, check results, escalate. Tools are registered and permissioned centrally, never ad hoc.
• Monitor and escalate Watch a stream, detect a condition, raise a case with the evidence attached.

A common mistake: building a multi-agent architecture because it is interesting. Most enterprise problems are one well-grounded model with good retrieval and a clean tool interface. Multi-agent designs multiply failure modes, cost and debugging effort, and should be used only where a single agent has demonstrably failed.

Governance, risk & responsible AI

Speed and control only conflict when governance is a committee. When it is written standards plus automated enforcement, both come from the same place.

What "production-ready" means, written down

Risk-tier every model, not just every agent

A meeting summarizer and a model that sets a process parameter, prices a contract or informs a regulatory filing do not deserve the same review. Higher tiers get locked model versions, formal change control, independent validation by people outside the build line, and drift monitoring with management-of-change when the process shifts. Lower tiers get a light, fast path. Proportion is what lets the organization move quickly where it is safe.

Anchored in recognized frameworks

The frameworks converge on four things: risk-based classification, transparency, meaningful human oversight and accountability. Every higher-tier review also asks three ethical questions: how serious could the harm be, who is most vulnerable, and who holds responsibility?

A short policy stack and a few clear forums

• Policy stack AI policy and principles; acceptable use; risk classification; data for AI; model and agent lifecycle; third-party AI; AI incident response.
• Steering committee · quarterly Strategy, risk appetite, funding and the highest-tier approvals, with internal audit observing.
• Governance council · bi-weekly Lower-tier approvals, policy, exceptions and incidents, with security, legal, privacy and data governance.
• Data council and site champions · monthly Standards, glossary, quality targets and data contracts; adoption, feedback and intake from the front line.

Risks I treat as first-class

• Intellectual property and trade secrets: contractual and technical guarantees that no vendor trains on company data, and classification-aware routing so the most sensitive material reaches only approved deployments.
• Regulatory and claims exposure: anything that could become a submission or a public claim stays human-approved with full traceability, indefinitely.
• Data residency and cross-border transfer: the gateway routes by data classification and jurisdiction, because asking each team to get it right is not a control.
• Entitlement leakage: zero tolerance, measured and reported.

Economics of AI

Enterprise AI programs rarely fail on capability. They stall when unit economics turn out to be indefensible at scale: a per-query cost that was invisible for forty pilot users becomes a line item someone has to defend for four thousand.

Where the money actually goes

• Context bloat Stuffing everything retrievable into the window because it is easier than retrieving well. Usually the largest avoidable line.
• Over-powered routing Sending classification and extraction to a frontier model because it was the scaffold default.
• Retry and loop waste Agents that re-plan on ambiguity instead of escalating. Cost grows non-linearly.
• No caching The same questions answered from scratch hundreds of times a day.

The optimization ladder

The harness matters more than the horsepower. A cheap model that starts with company context, the right skill pack and clean tools routinely beats an expensive model that has to research what the company is on every call.

What I report every month

• Cost per outcome by capability, trended: the headline number
• Spend by domain, attributed at the gateway and reconciled with Finance
• Cache hit rate, and the spend it avoided
• Routing mix by model class, with drift flagged
• Idle capability spend: what we pay for things nobody uses

Buy, partner or build

These decisions set cost structure, timelines and lock-in for years, so I run every one through the same short rubric. Answer the questions for a capability you are weighing.

• Buy Clear market solutions exist and the capability is not a differentiator. Require modular, interoperable products on open standards, and an exit plan before signing. Typically: Workplace assistants, enterprise search, data catalogs, cloud security posture, managed model hosting.
• Partner Share risk with front-runners on work that is not a product yet, or that matters but cannot yet be run in-house. We specify the architecture and own the result; the partner accelerates it. Typically: Physics-grounded digital twins, vision inspection at the line, integration with operational-technology data.
• Build selectively Intersects core value creation and creates an advantage competitors cannot buy. Owned by employees, whoever writes the first version, and built on the shared platform. Typically: Process, yield and quality models, the business glossary and process maps, agents that act on proprietary data.

Partners accelerate work we have specified; they never define the architecture. Anything load-bearing, such as the gateway, the evaluation harness and the context layer, is owned by employees, whoever writes the first version. Every vendor faces three tests: can we leave within two quarters, does the contract prohibit training on our data, and does using it deepen our own team's capability or replace it?

• Composable Modular parts that each do one thing well and connect through clean interfaces: APIs, MCP, OpenTelemetry, open table formats, SQL.
• Compostable Every part replaceable without a redesign. The model chosen today will not be the one in production in eighteen months, so each decision is recorded with its exit plan.

Open-source alternatives, layer by layer

Open source is free to download, not free to run. Budget for patching, security review, support and license checks, since some open models carry use restrictions, and screen model provenance against the business's own supply-chain and customer requirements.

Organization & talent

The org chart is a leverage question, not a staffing question. A deliberately small central core owns what must be done once; embedded practitioners sit with the business; an independent function validates the highest-risk models.

• Embedded pods Close to the decision. Data scientists and AI engineers sit with operations, supply chain, R&D, commercial and finance, with a business owner setting priorities and measuring value.
• Central platform & methods Built once, used everywhere: platform engineering, evaluation and operations, architecture and governance.
• Independent validation A small model-risk function that validates the highest-tier models and reports outside the build line, so the organization never grades its own work.

Who decides what

What each side owes the other

Talent: the part only a leader can do

• Hire deliberately mixed profiles Statisticians and forecasters, optimization specialists, ML and GenAI engineers who ship, and domain engineers who want to model.
• Grow on a real technical ladder Principal and distinguished tracks that pay as well as management, so the best scientists keep doing science.
• Rotate for domain fluency Embedded practitioners spend two or three quarters in a domain, then return to the core with what they learned. Patterns that work become part of the paved path.
• Four competency tracks Platform engineering, applied AI engineering, AI product management, and evaluation and operations, each with levelled expectations and portfolio-based promotion.
• One hiring bar Structured hiring and performance management across every location, the same process I built from zero at a startup and run today across two countries.
• Literacy beyond the team Analysts, engineers and leaders across the business learn to frame a decision, read a forecast interval and question a model.

Change & adoption

Adoption is earned, not mandated. If someone can get an answer faster by going around the platform, they will, and they should. That is a defect report about the platform.

• Capacity, not cuts The goal is fewer repetitive tasks, faster decisions and more room for engineering, customer and creative work. Where workforce change is genuinely needed, the answer is transparency, reskilling and redeployment, not a promise that technology never affects jobs.
• Teams move up the stack Existing BI and analytics teams are developed, not displaced. They move from one-off reports to building the reusable data products and agentic tools everyone else uses.
• Treat internal users as customers Design for the person doing the work, not the reporting layer. A tool that costs a frontline user time will be abandoned by week three, whatever the mandate says.
• Earn trust before asking for it Start with grounded, cited assistance. Never ask an expert to trust a model whose failure modes you cannot explain. Experts forgive a model that is uncertain and never forgive one that is confidently wrong.
• A literacy ladder open to everyone AI fluency is a company-wide ladder anyone can climb, not a perk for a technical elite.
• Listening before pitching Every program starts with listening on the floor, in the lab and with the field teams. The AI lead in the room is not the domain expert, and should not act like one.

One front door

Getting an answer today often means knowing which system holds the data, which analyst owns it, whether a dashboard exists and whom to ask if it does not. The end state is one governed front door, inside each person's existing permissions, that composes an answer or a live view from approved data products rather than a one-off chat reply. It is also the single best lever on cost, because every call starts warm with the right context.

How a program matures

Data and AI programs that last move through recognizable stages, and each stage has a different job: understand, decide, ship, prove, widen and industrialize. Skipping a stage is how most programs stall. The early work is weighted toward listening and toward domain knowledge: architecture can be proposed quickly, but understanding how the business actually runs cannot.

• Stage 1 · Baseline what exists Most programs begin with more AI activity than anyone has counted. The first job is an honest inventory of every initiative, with its cost, its owner and whether it is really in production, alongside an understanding of how the work actually runs on the floor, in the lab and in the field. Security, legal, architecture and finance are engaged here so they shape the standards rather than review them. Deliverable: A written baseline and a shortlist of lighthouse use cases with named owners.
• Stage 2 · Decide and publish Platform architecture agreed. The production-ready definition and authority tiers drafted with security, legal and compliance, then published. Gateway build started. Team design confirmed. Two lighthouse use cases selected, with baselines agreed in writing with Finance. Deliverable: Published standards, an agreed roadmap, a funded plan, two use cases in build.
• Stage 3 · Ship something real Gateway live with routing, logging and cost attribution, plus a migration plan for existing direct model use. Golden path v1. The first lighthouse in production with a named owner, dashboards and a measured baseline. The first monthly value and cost report. Deliverable: A working platform with one real capability on it.
• Stage 4 · Prove the path Second lighthouse in production. All new AI work uses the gateway. Embedded practitioners deployed. Review service levels published and reported. Competency model released. First value re-measurement against the agreed baselines.
• Stage 5 · Widen Every priority area has at least one production capability. Cost-per-outcome trends reported. The first rotation completes and its lessons join the paved path. Vendor strategy formalized under the two-quarter exit test.
• Stage 6 · Industrialize Reuse rate becomes a reported metric. The first capabilities are retired for missing their value threshold, a sign of health. The next roadmap is built with domain leaders, not for them.

What a maturing program should be able to show

• A platform every team uses because it is the fastest route, with a pilot-to-production rate anyone can state as a number.
• A benefits register agreed with Finance, with baselines captured before launch and figures that hold up line by line.
• A production bar enforced in the release gate, zero entitlement violations, and security, legal and compliance calling themselves co-authors.
• A reported, rising reuse rate and a retired-capabilities list that is not empty.
• A lean team on a published competency model, with internal candidates filling senior roles.

The scorecard

Model count, pilot count and people trained are activity metrics. They tell a leadership team nothing about whether the investment was worth making. These are the measures a program should be held to.

Reporting is short enough to be read: one page monthly on value, cost, adoption, reliability and risk; a quarterly portfolio review of what is being promoted and what is being retired.

The uncomfortable metric: capabilities retired for missing their value threshold. If that number is zero after a year, either the thresholds are not real or nobody is checking. I report it deliberately.

What I avoid

These are the commitments that are easy to make at the start of a program and hard to keep in month eight, when something is behind and a shortcut is available.

• Build a shadow delivery organization A central team that competes with domain teams ends up owning a portfolio it cannot operate. The platform's product is the paved path.
• Start a pilot without a production owner The pilot graveyard is filled with pilots nobody was ever going to run. Saying no early is worth more than the pilot.
• Grant autonomy before evaluation exists No agent acts without a golden dataset, a measured threshold, a tested rollback and a named owner.
• Accept lock-in for short-term speed If we cannot leave within two quarters, it is a strategy commitment, not a tool choice, and it goes to the executive sponsor.
• Chase a model zoo Supporting every new model and framework is a maintenance tax. A small approved set, reviewed on a schedule.
• Overstate the value No hours-times-rate arithmetic presented as cash and no pilot results extrapolated to the enterprise.
• Centralize domain judgment What counts as a good answer in a domain is the domain's call. The moment the center defines it, the standards stop being trusted.
• Hire ahead of the operating model Twenty people without a paved path produce twenty bespoke solutions. Run light, then hire into a structure that makes each person more effective.