AI Can Read a CAD File Now; Your Engineering Data Still Has No Catalog
Why file-level CAD reading capability does not make an engineering estate AI-ready, and what a governed engineering data catalog must contain: identity, lifecycle state, structure, effectivity, change history, ownership and enforced access, plus acceptance queries to test before committing to a model.
A multimodal model can now open a CAD file, describe its geometry, read its parameters, and in some cases rewrite the code that produced it. That is a genuine advance, and it is being read as a signal that engineering data is finally ready for AI. It is not. Reading one file and answering questions across a vault of parts, revisions, assemblies and permissions are different problems with different failure modes, and the second one is where most enterprise AI programs in engineering will stall.
The argument here is that the catalog — not the model — is the unit of investment. The sections below explain why current thinking conflates file-level capability with estate-level readiness, what a governed engineering catalog must actually contain, how to test your own data before committing to a model, what breaks when fields are missing, and why none of this requires replacing your PLM.
The Demo Is Real. The Inference Is Wrong.
The flawed inference runs like this: a model can interpret geometry and edit parametric code from a prompt, therefore our engineering data is AI-ready. The first clause is supported by benchmark evidence. The second does not follow from it, because the benchmark measures a model against a curated task, not an organization against its own data estate.
The BenchCAD benchmark is the clearest current evidence of where capability actually sits. It evaluates frontier models on visual question answering, code question answering, image-to-code generation and instruction-guided code editing across 17,900 executable CadQuery programs spanning 106 industrial part families, with execution-verified ground truth. Its headline finding is diagnostic rather than triumphant: simple API-level edits are nearly solved by modern models, while compositional edits remain difficult. Replacing the textual instruction with a target render collapses every model to near-zero, because a render specifies geometry but not numbers. Supervised fine-tuning and reinforcement learning improve in-distribution performance, but generalization to unseen part families remains limited.
Three scope limits matter for anyone drawing an enterprise conclusion from this. The benchmark uses curated, expert-verified part families rather than a production vault with duplicate part numbers and abandoned revisions. Its ground truth is executable code and STEP output, not released status, effectivity or access rights. And its tasks are per-item: reproduce this part, edit this feature. Nothing in it tests whether a model can find the right part among forty similar brackets, at the revision a customer program requires, for a user cleared to see it.
That is the warrant. Capability inside a file is not capability across a data estate. A benchmark can tell you the model is getting better at the file. It cannot tell you your data is governable.
A File Answers Questions About Itself. A Catalog Answers Questions About the Business.
The distinction is easiest to see in the questions each layer can answer.
A model reading a single CAD file can tell you its geometry, its features, its parameters, its bounding box, and how a requested change would alter the solid. Those are questions the file answers about itself. Ask it which revision is released, which assembly consumes the part, whether it is approved for a given customer program, who is allowed to see it, or which of forty similar brackets is the current standard, and the file has nothing to say. Those answers live in configuration records, not in geometry.
The configuration-management literature is explicit about what those records contain. NASA-STD-0005 requires suppliers to assign unique configuration identifiers to products and documents, including revision and version numbers; to assign a new part identification number whenever a change affects form, fit or function; to establish functional, allocated and product baselines at defined points in the life cycle; and to maintain configuration status accounting that records current versions, drawing revision levels and revision history. It also distinguishes as-designed, as-built and as-tested configurations, and requires that deviations between them be recorded with rationale.
ISO 10303-44 covers the same territory from the data-model side. Its configuration management schema addresses the identification of items whose composition is managed, the association of appropriate versions of a product to build a configuration item, and effectivity — with serial-numbered, dated and lot effectivity defined as distinct mechanisms. The 1994 edition of the same part notes that an organization may track design changes for a base part and establish effectivity conditions for its use in various assemblies.
These are the fields that turn a file into a governed record. Keep the scope honest: the standards describe what configuration management requires of an organization. They do not certify that any particular PDM or PLM product implements every clause, and they say nothing about whether a given AI vendor's connector respects them.
What a Trustworthy Engineering Catalog Must Contain
The specification below is organized in layers because the layers fail differently. A catalog with clean identity but no access enforcement is a discovery tool that leaks. A catalog with access enforcement but no lifecycle state will confidently recommend obsolete parts.
Identity. A unique part or item identifier per configuration item, plus revision and version numbers, held as attributes rather than inferred from the filename. NASA-STD-0005 requires a discrete part identification number for each configuration item and its subordinate parts and assemblies, and a new number when a change affects form, fit or function. The practical test is whether two systems resolving the same part number land on the same record.
State. Lifecycle status — in work, released, obsolete, and whatever intermediate states your change process defines — together with the rules governing transitions between them. Status should be a controlled value, not free text. A catalog metadata model that types lifecycle state as an enumeration and certification dates as ISO 8601 timestamps makes those fields machine-checkable; the Google Cloud Knowledge Catalog metadata documentation lists exactly these field types, with environment values as an enum and last-certified date as a timestamp.
Structure. Parent-child assembly relationships and where-used. This is what lets a query answer "what breaks if this part changes" rather than "what does this part look like." ISO 10303-44's product structure schema is the reference model for expressing these relationships independent of any one CAD format.
Effectivity. Which serial number, date or lot a given configuration applies to. Without it, an analysis cannot distinguish the configuration that was designed from the one that was built, and NASA-STD-0005 treats that distinction as a recordable fact rather than an assumption.
Change history. What changed, why, under which change order, and who approved it. Status accounting in NASA-STD-0005 covers current versions, approval dates and authorities, related change actions and prior-version history. The rationale matters as much as the diff: a reviewer verifying an AI-generated answer needs to know why the current revision superseded the last one.
Ownership and stewardship. A named accountable owner per domain. Catalog governance fails quietly when nobody owns a field, because incomplete values look like valid ones.
Access. Classification and permissions enforced at the data layer, not only in the application that happens to front it. Microsoft's Azure Cloud Adoption Framework guidance is direct on this point: a sensitivity label on a Fabric item does not by itself enforce equivalent access restrictions, and platform permissions continue to control access. The same framework recommends testing whether required protection survives transitions between platforms, including paths where data leaves a more controlled environment.
One cross-cutting control ties the layers together: glossary governance. The same Microsoft guidance recommends publishing approved definitions through a unified catalog so users can discover the meaning associated with governed data. Without agreed definitions, "released" means one thing in one team's export and something else in another's, and no amount of field-level typing repairs the mismatch.
The Failure Modes You Will Actually Hit
The scenarios below are illustrative inferences drawn from the field definitions above. They are not observed incidents, and no customer data stands behind them.
Revision absent. Two engineers ask an assistant for the latest bracket design in the same week. Each retrieval resolves "latest" against a different source — one against a shared drive sorted by modification time, one against a PDM export sorted by check-in — and each gets a different file. The assistant answers both questions fluently and confidently, and one of the two answers is wrong. Nothing in the model's behavior signals which. The failure is not that the model hallucinated; it is that the catalog could not define "latest" as a single deterministic query.
Lifecycle state absent. A design assistant trained to suggest reusable components recommends a part that was obsoleted two years ago but remains in the vault with complete geometry. The geometry is correct. The recommendation is not, because the field that would have excluded it was never populated or never exposed to the retrieval layer.
Permissions absent. A user asks a cross-program question and the assistant returns items from a restricted customer program because classification lived in the application layer and the AI workload queried the data layer directly. The Microsoft guidance cited above describes exactly this gap: labels classify, platform permissions enforce, and the two must be tested together across platform transitions.
Effectivity absent. An analysis blends as-designed and as-built configurations because the catalog records neither serial nor lot effectivity, and the two populations are indistinguishable in the query. NASA-STD-0005 treats the as-built versus as-designed difference, including approved waivers and deviations, as a record that must be maintained — precisely because downstream analysis that ignores it produces a plausible wrong answer.
These failures share a shape. The model does what it was asked. The catalog could not constrain the question.
That is why vendor warnings about AI accuracy are necessary but not sufficient. Autodesk's Assistant limitations documentation states plainly that AI-generated responses may not always be complete or accurate, that the Assistant may misunderstand a question or provide outdated information, and that users should double-check critical information and review automated changes before saving or sharing. That is sound guidance. It is only actionable if the reviewer can determine which revision they are verifying against and whether the answer respected their access rights — which is a catalog capability, not a model one.
Test Your Data Before You Test the Model
You can run this assessment before buying anything. The method is to write down the queries the catalog must answer deterministically, define a pass criterion for each, and run them against a sample rather than the whole estate.
Acceptance queries.
Given a part number, return the current released revision in a single query. Pass: one row, with revision identifier and release date, and no ambiguity about which record is authoritative.
Given a part, list every assembly that consumes it, with the effectivity of each use. Pass: complete where-used results including serial, date or lot conditions where they apply.
Given a released item, produce its change history with rationale and the change order that authorized each step. Pass: a reviewer can reconstruct why the current revision exists.
Given a release event, show who approved it and when. Pass: named approver and timestamp, not a system account.
Given a user's identity and classification, confirm that a query issued on their behalf cannot return items above their clearance. Pass: tested at the data layer, including a path where the data leaves the primary platform.
Given a part number, confirm that two systems resolve it to the same record. Pass: identical identifier and revision from both, with any discrepancy explained rather than averaged.
Sampling test. Draw a random sample across part families rather than from your best-curated family. Coverage gaps are usually uneven: the flagship product line has clean metadata and the acquired product line does not, and an average completeness score hides the difference. Score each sampled part against the field layers above and report completeness by family, not in aggregate.
The pass bar. If the catalog cannot answer these queries before the AI project starts, the AI project will be measuring catalog quality, not model quality. That is not a reason to delay the catalog work. It is a reason to sequence it first, because a model evaluation run against an ungoverned catalog produces a number that cannot be attributed to either the model or the data.
This Is a Catalog Problem, Not a PLM Replacement Problem
The strongest objection is that closing this gap means ripping out and replacing the PLM system. The opposite is usually true. Most of the required fields are already defined inside PDM and PLM systems — revision control, BOM management, engineering change orders and lifecycle states are standard PDM functions, as Autodesk's PDM overview describes. The gap is typically exposure, consistency and enforcement: the fields exist in the system of record but are not exposed as a governed, queryable catalog layer that AI workloads and analytics can reach under consistent access rules.
Tech-Clarity survey of 248 manufacturers: share reporting each method for communicating engineering changes with third parties, Top Performers versus Others. These are correlations among surveyed manufacturers and do not establish that adopting PLM or PDM produces the outcome.
The survey evidence should be read at its actual scope. Tech-Clarity's research, based on 248 manufacturer responses, found that top performers were nearly twice as likely to maintain up-to-date models, and that compared with lesser-performing competitors they were 85% more likely to use PLM and twice as likely to have CAD models update automatically with third parties. Those are correlations among surveyed manufacturers. They do not establish that buying PLM produces the outcome, and the report itself frames PDM/PLM as what makes real-time updates possible rather than as a guarantee of performance.
The baseline is uneven. A 2017 Engineering.com survey, as summarized by Oleg Shilovitsky, reported that 49% of users still had no formal PDM system — an improvement over the roughly 60% cited in 2012, but a reminder that a large share of engineering organizations are starting from unmanaged files. That figure is now several years old and should be treated as directional context, not a current statistic.
The practical path has four steps. Inventory what the PLM already holds and which fields are populated. Define the canonical field set and the glossary that makes values comparable across teams. Expose those fields through a governed catalog layer that AI and analytics can query, with access enforced at that layer. Then, and only then, point models at it. Replacing the system of record is a separate and much larger decision, and it is not a prerequisite for any of the above.
Where This Leaves You
The model is not the bottleneck. The catalog is. And the catalog is a governance deliverable your team can specify, test and fund like any other.
The sequence is short. Define the field set and glossary. Run the acceptance queries against a random sample and record where they fail. Fix identity and lifecycle state first, because every other query depends on knowing which record is authoritative and whether it is current. Then expose the governed layer to AI workloads, with access enforced there rather than in the application.
For leadership, the implication is budgetary. Catalog work belongs inside the AI program, not beside it as an IT side project, because the AI program's output quality is capped by the catalog it queries. A model that reads a CAD file perfectly still cannot tell your engineer which revision is released. That answer has to come from somewhere, and the somewhere is a catalog you decided to govern.
FAQ
Why is reading a file different from a governed catalog? A file answers questions about itself: geometry, features, parameters. A catalog answers questions about the business: which revision is released, which assembly consumes it, who may see it, and which configuration applies to a given serial or date. Benchmarks like BenchCAD measure the first capability on curated part families; they do not test the second across a production estate.
What are the minimum fields and controls? Unique part identifiers with revision and version distinct from filename; lifecycle state with defined transitions; parent-child structure and where-used; effectivity by serial, date or lot; change history with rationale and approving change order; a named owner per domain; and classification enforced at the data layer. Glossary governance keeps field values comparable across teams.
How do I test AI-readiness before committing? Write the queries the catalog must answer deterministically — current released revision, full where-used with effectivity, change history with rationale, approver and date, access enforcement, and cross-system identifier resolution — and run them against a random sample of parts across families. If they fail, the AI project will measure catalog quality rather than model quality.
What breaks when revision, state or permissions are missing? In illustrative scenarios, not observed incidents: two engineers retrieve different "latest" files and one answer is confidently wrong; an obsolete part is recommended for a new design; restricted program data reaches a user who should not see it; and as-designed and as-built configurations are conflated in an analysis. In each case the model behaves as instructed and the catalog fails to constrain the question.
Does this require replacing PLM? No. Most required fields are already defined inside PDM and PLM systems. The gap is usually exposure, consistency and enforcement, so the practical path is to inventory what the PLM holds, define canonical fields and a glossary, expose them through a governed catalog layer, and enforce access there. Replacing the system of record is a separate and much larger decision.
find out more
https://singdata.com/trending/claiming-singdatas-credit-1tb-lakehouse-signup-activation/
https://singdata.com/trending/apache-iceberg-decentralized-metadata-2025/
https://singdata.com/trending/efficiently-analyze-big-data-strategies-and-tools/