Date: 2026-07-13.

Two forces are reshaping every enterprise data strategy at once. Consolidation pulls all data into a single lake, and anything left outside is treated as a silo to be cleaned up. Intelligence puts AI on top of that lake, so people ask questions in plain language and agents act on the answers. Both forces are real, both have budgets behind them, and together they pose a question a budget owner can now ask with a straight face. If the lake already stores the measurement files and an AI can answer questions about them, why keep a dedicated test data system based on ASAM ODS at all?

The argument that follows takes the opposite position from that question. A data lake with a language model on top is the first plausible replacement for dedicated test data management that someone who has never had to defend a result in an audit would understand. It does not survive contact with how engineering results are actually used. The lake does not retire the governed test data layer. It raises that layer's value, because the more data an enterprise consolidates and the more it asks an AI to act on that data, the more it needs results it can prove. This piece answers the consolidation force of the transformation. Its companion, When AI Comes for Test Data, Standardization Amplifies, answers the intelligence force, and both stand on the same foundation.

The convenient architecture has a name on every whiteboard where it appears. Throw the files at the AI. Dump raw measurement files into cheap storage, skip the standardization step, and let a model interpret the bytes on demand. It demos impressively, and that is precisely the trap. The demo answers a question. It does not produce a result anyone can stand behind. The difference shows up on five counts. The first four are properties of the data layer that the model cannot infer. The fifth is the bill that the convenient architecture quietly runs up.

A measurement file is a sequence of bytes until something supplies the units, calibration, sample rate, and channel-to-sensor mapping that make those bytes represent a physical quantity. A standardized layer holds that meaning at the source, recorded once and identical for every reader. A model that interprets raw files invents meaning at read time, so the same file answers differently to differently worded prompts. An engineering quantity that shifts with phrasing is not an answer. It is a guess wearing the costume of one.

A verdict that a release decision is based on must return the same value when it is rerun next quarter by a different engineer. A query against a standardized layer is reproducible by construction, because the data and its semantics are fixed. Synthesis from raw bytes by a probabilistic model is not reproducible by construction, because the model, the prompt, and the interpretation all drift. Reproducibility is the one property that the convenient architecture cannot offer, and it is the property that regulated engineering cannot do without.

Trust in a number comes from being able to walk back to where it came from, through its transformation and its source measurement, and to show that walk to an auditor. A governed layer records that lineage as it produces the number. A model answering over a heap of files has no lineage to show, only an output and the file it happened to read.

ISO 9001 traceability, IATF 16949 audit trails, and emerging regulatory obligations all demand the same thing, that a result be attributable and repeatable on demand. A governed, standardized layer is built to produce that evidence. A lake of raw files, combined with a language model, produces an answer with no evidence, which is the one combination an audit cannot accept.

This is the count a budget owner feels first, and it runs counter to the intuition that raw files are the cheap option. Throwing files at a model reinterprets the bytes on every single query, loading, parsing, inferring, and validating each time, and an OEM environment runs thousands of those queries a day. A query against a governed layer reads from a structured store once and returns results in milliseconds, with no per-call inference bill. The convenient architecture is not only the least provable one. It is the most expensive one, exactly where volume is highest, and that is the bill that arrives after the demo has won the room.

Read together, these five counts describe what answering a test data question actually requires once the work is real. Governed meaning, a reproducible result, traceable lineage, an audit that holds, and a cost that does not balloon with volume. None of those live in the model. All of them live in the standardized layer beneath it.

What the lake's own flagship reference actually shows. Mercedes-Benz built petabyte-scale car measurement storage on Databricks, 21 test vehicles, 30,000 to 60,000 signals each, 40,000 hours of recordings. It looks like a platform replacing a test data system, and it is the opposite. The team used ASAM MDF for the raw files, then rebuilt an ODS-shaped semantic layer by hand, the discovery, the multi-level filtering, and the signal-level metadata that an ASAM ODS application model ships out of the box. So they rebuilt ASAM ODS, and could afford to only because they are Mercedes, with an engineering team most OEMs, test service providers, and equipment vendors do not have. What a hand-built model buys is also narrower than what it replaces. It serves their one use case rather than a portable standard, it exposes no standardized interface, so every tool has to integrate against it one at a time, and it ties their measurement data, long term, to a single vendor's platform and its running cost. ASAM ODS is that same layer as a standard, maintained once for the whole industry. The account is Databricks' own published customer story.

This is not a layer the market still has to build. HighQSoft has run it in production for years at automotive, maritime, and battery testing organizations, and the components map directly onto the counts and the layers above.

Janus federates measurement sources in place through its handler architecture and maps them onto the standardized ODS layer, so the governed meaning the first count demands travels to the data instead of forcing the data to move. A handler that speaks Apache Arrow gives zero-copy access to mass data in open formats such as Parquet, and the ODS meaning stays in the handler's mapping. The lake stores the files. Janus is what makes them mean something an agent can trust.

Merlin runs the analysis and records the inputs, the script version, the parameters, and the source with every job, so each result carries full lineage by construction. A columnar stage built on Apache Arrow and DataFusion pushes the computation to where the bulk data lives, so an evaluation runs its filter at the data instead of streaming rows to a worker. That is three counts at once, reproducibility, traceable lineage, and an audit that holds, built rather than promised.

The MCP Server connects assistants such as Claude and ChatGPT to the governed data, and HQL keeps the translation from plain language deterministic. The engineer asks in conversation, and the retrieval underneath stays exact. AI on the outside, governed meaning on the inside, each exactly where it belongs.