Asset Administration Shell: Industry 4.0 Submodels Guide

Asset Administration Shell: Industry 4.0 Submodels Guide

Asset Administration Shell (AAS): Industry 4.0 Submodels Guide

Every machine builder ships the same facts in a different container: a PDF nameplate, a spreadsheet of technical data, a STEP file, a proprietary configuration tool. Integrators re-key those facts by hand, and the copies drift apart the moment anything changes. The Asset Administration Shell (AAS) is the industry’s answer: a standardized, machine-readable envelope for everything known about an asset, split into semantically labelled submodels that software can discover and interpret without a human reading a manual.

This matters now because the specification has stopped moving fast enough to be an excuse. Part 1 (the metamodel) and Part 2 (the API) have been stable at the 3.x level since 2023, a 3.1 line shipped in 2025, and the IDTA published a 3.2 revision of Part 1 in July 2026. Meanwhile regulation, from battery passports to the wider Digital Product Passport, is turning “publish a standard digital description of your product” from a nice idea into an obligation. You will leave this guide knowing how the metamodel is built, which specification part answers which question, how submodel templates and semantic identifiers create meaning, how AAS compares with OPC UA and DTDL, and how to stand up a first shell.

What this covers: the AAS specification family, the metamodel, semantic IDs, IDTA submodel templates, the REST API and registries, AASX packaging, open-source tooling, mapping to OPC UA and DTDL, a runnable JSON example, and the failure modes teams actually hit.

Context and Background

Industrial automation has always had a data-description problem layered on top of a communication problem. Fieldbuses and protocols such as PROFINET and OPC UA moved values between devices. They did not agree on what a “nominal speed” is, who owns the nameplate, or how a supplier hands a customer a calibration certificate. The Reference Architecture Model Industrie 4.0 (RAMI 4.0) framed the gap by asking for an “administration shell” around every asset, physical or not, that makes the asset a participant in a network of information.

That idea was first elaborated by Germany’s Plattform Industrie 4.0 and then moved into a user organisation, the Industrial Digital Twin Association (IDTA), which now maintains the specification parts and the submodel templates. The international anchor is the IEC 63278 series, “Asset Administration Shell for industrial applications”; IEC 63278-1 was published in 2023 and covers the shell concepts. The IDTA documents are where the implementable detail lives: UML metamodel, JSON and XML schemas, OpenAPI files, and the AASX packaging rules. You can read them at the IDTA content hub.

It helps to be precise about what the AAS is not. It is not a protocol for streaming 1 kHz vibration data, and it is not a replacement for a PLC program or a historian. It is a metadata and structure layer: it says what the asset is, which aspects exist, what each value means, and where to fetch the live values from. Several of our other pieces look at the neighbours. The AAS reference architecture overview covers deployment topologies, and the comparison of AAS, DTDL and OPC UA information models goes deep on modelling philosophy. This guide concentrates on the submodel, because the submodel is where interoperability is actually won or lost.

Three forces explain the momentum. First, supply-chain data sharing: consortia such as Catena-X, which we cover in the automotive data space reference architecture, use AAS-shaped digital twins to exchange product data across company boundaries. Second, regulation: the EU battery regulation and the Ecodesign for Sustainable Products Regulation require standardized, accessible product data, and the IDTA has published passport-oriented submodel templates in response (see our Digital Product Passport data model analysis). Third, tooling maturity: open-source servers, SDKs and editors now exist, so a team can prototype in an afternoon rather than writing a metamodel parser first.

A note on terminology that trips up newcomers. “Digital twin” in the AAS world means the shell plus its submodels, possibly with live data links. A “type 1” shell is a file; a “type 2” shell is a running server answering API calls; a “type 3” shell is proactive and negotiates with other shells. These three categories come from the original Plattform Industrie 4.0 concept papers and are about behaviour, not about a vendor product tier. Most production systems today are type 1 (AASX files exchanged between companies) or type 2 (a repository server), and the type 3 vision remains largely a research topic.

The AAS Specification Landscape and Metamodel

The AAS specification is a family of numbered parts, each answering a different question. Part 1 defines the metamodel (what a shell is), Part 2 the HTTP API (how to talk to one), Part 3a the IEC 61360 data specification (how to describe a concept), Part 4 security (who may do what), and Part 5 the AASX package file format (how to ship a shell as a file). Submodel templates sit on top and are maintained separately.

Asset Administration Shell AAS metamodel: shell, asset information, submodels, elements and concept descriptions

Figure 1: The AAS object structure. A shell references submodels; submodels contain typed elements; elements carry semantic IDs that resolve to concept descriptions.

Figure 1 shows the containment and reference structure. The long description for readers who cannot see the image: an AssetAdministrationShell holds one AssetInformation object and a list of references to submodels. Each Submodel owns a tree of submodel elements such as Property, MultiLanguageProperty and SubmodelElementCollection. Elements point through a semanticId to an external definition, typically an ECLASS or IEC Common Data Dictionary entry, and an optional ConceptDescription inside the environment can carry that definition locally.

Part 1: the metamodel in detail

The Part 1 document, IDTA-01001, is the normative description of the classes. At the time of writing the IDTA download archive lists versions 3.0 (2023), several 3.0.x corrections, 3.1 (2025), 3.1.1, 3.1.2 (late 2025), and a 3.2 document dated July 2026. Our dedicated post on the AAS metamodel 3.2 release and migration covers what changed; for this guide, the stable core is what matters.

The AssetAdministrationShell is an Identifiable, which means it has a globally unique id (an IRI, URN or similar string) plus an idShort, a short human-readable name that need only be unique among siblings. It has exactly one AssetInformation, an optional derivedFrom reference (type-to-instance lineage), and zero or more references to submodels. Notice that the shell does not contain the submodels; it references them. That single design choice is what lets a supplier host a Nameplate submodel while a service partner hosts a Maintenance submodel for the same shell.

AssetInformation carries the assetKind (Type, Instance, Batch, Role or NotApplicable in the current text), an optional globalAssetId, any number of specificAssetIds (name and value pairs such as a serial number scoped to a manufacturer), an optional assetType, and an optional default thumbnail. A constraint in the specification requires either a global asset ID or at least one specific asset ID. This matters operationally: the asset ID is what discovery services search on, so an asset with no resolvable identifier is invisible to the rest of the ecosystem.

A Submodel is also Identifiable, has a kind (Template or Instance), a semanticId naming the template it follows, optional qualifiers, and a tree of SubmodelElements. The kind flag is not cosmetic. A Template submodel holds placeholders and cardinality qualifiers describing what an instance may contain; an Instance holds real values. IDTA publishes templates; you instantiate them.

The element zoo is deliberately small. In the text we reviewed, the concrete types are Property, MultiLanguageProperty, Range, File, Blob, ReferenceElement, RelationshipElement, AnnotatedRelationshipElement, SubmodelElementCollection, SubmodelElementList, Entity, Operation, Capability and the event types (BasicEventElement). The 3.2 text flags Range, BasicEventElement and the event elements as experimental, so build conservatively on them. Practical guidance on the common ones:

  • Property holds a single typed value; valueType uses XSD types such as xs:string, xs:double or xs:dateTime.
  • MultiLanguageProperty holds a list of language-tagged strings, which is why product designations survive localisation.
  • SubmodelElementCollection groups named children; SubmodelElementList is an ordered list whose items share one type and semantic ID, which suits tables of rows.
  • File and Blob reference or embed binary content such as a PDF manual, a STEP file or a certificate.
  • Operation declares input, output and in-out variables, giving a way to describe invocable behaviour such as “start calibration”.
  • Entity models parts of a larger whole, and is the backbone of the bill-of-materials submodel.

Referencing is handled by Reference objects made of ordered Keys. A key has a type (for example Submodel or Property) and a value; a ModelReference chains keys from an identifiable down through idShorts, while an ExternalReference points outside the model, such as to an ECLASS IRDI. Getting this distinction right avoids a whole class of bugs when you serialize.

Part 2: the API

Part 2, IDTA-01002, defines HTTP interfaces and the OpenAPI files that go with them. The specification’s change notes list the 3.1 line adding query operations for the repositories and registries, bulk registry operations, and a discovery operation named SearchAllAssetAdministrationShellIdsByAssetLink that replaces a deprecated predecessor. Pagination via limit and cursor applies to the GetAll operations, and the Identifier data type length grew from 2000 to 2048 characters.

The API is split into services so that a deployment can implement only what it needs. The set, in practice: AAS Repository (hosts shells), Submodel Repository (hosts submodels), Concept Description Repository, AAS Registry and Submodel Registry (hold descriptors that say where a shell or submodel lives), AAS Discovery (maps asset IDs to shell IDs), and a serialization service for exporting packages. Each service has defined service profiles that name which operations a server must support, so two vendors can claim conformance to a profile and be tested against it.

Two conventions bite every first-time client author. Identifiers in URLs are base64url-encoded (without padding), so a submodel with id https://example.com/ids/sm/nameplate/pump-4711 appears in the path as a long opaque string. Paths inside a submodel use idShortPath syntax, such as Markings[0].MarkingName, which is URL-encoded rather than base64url-encoded. Responses can be shaped with modifiers: $value returns only values, $metadata only structure, $reference references, $path the idShortPaths, and level=core limits depth. Using $value for polling is what keeps a dashboard from downloading kilobytes of semantic metadata every second.

Part 3a and semantic data specifications

Part 3a describes the IEC 61360 data specification template, the structure that lets a ConceptDescription say “this property is a length, in millimetres, with this definition”. Preferred names, short names, unit, data type, definition and value lists live there. Units are a deep topic of their own, which we treat in the AAS units of measurement piece. The key idea here is separation: the submodel element says where a value sits; the semantic ID says what it means; the concept description or the external dictionary supplies the definition.

Part 4 and Part 5

Part 4 defines the security model: authentication via standard mechanisms, and an access-rule language that expresses which subjects may read or modify which parts of a shell, down to individual submodel elements and attribute-based conditions. Treat it as the specification most likely to be only partly implemented in a product you evaluate, and ask vendors which of its rule types they honour.

Part 5 defines the AASX package, covered in detail below. Put together, the spec parts form the map in Figure 2.

Asset Administration Shell specification parts: metamodel, API, data specification, security and AASX package

Figure 2: How the IDTA specification parts relate. Part 1 is the foundation; everything else either serves it, describes it or implements it.

The long description: the IEC 63278 umbrella points to Part 1. Parts 2, 3a, 4 and 5 all derive from the metamodel, submodel templates depend on both the metamodel and the data specification, and real software, from BaSyx and AAS4J to FA3ST and AASX Server, implements the API and the package format.

Semantic IDs, Dictionaries and Submodel Templates

Interoperability in AAS is not achieved by shipping JSON. Two companies can both emit a Property called Manufacturer and still disagree on whether it means the legal entity, the brand, or the plant. The AAS answers with semantic identifiers and submodel templates, and understanding the interplay is the most valuable thing a newcomer can learn.

How semantic IDs work

Every HasSemantics element, which includes Submodel and every SubmodelElement, can carry a semanticId: an external reference whose key points to a definition somewhere. Three families of identifier dominate.

  1. ECLASS IRDIs. ECLASS is a product classification and property dictionary widely used in German-speaking industry. Its identifiers have the shape 0173-1#02-AAO677#002, where the 0173-1 prefix identifies the ECLASS international data-structure registration, #02 marks a property, then a code and a version. The same identifier family is used in IEC 61360-style dictionaries.
  2. IEC Common Data Dictionary (CDD). The IEC maintains a dictionary of properties and classes, particularly for electrotechnical products, using IRDIs of a similar form.
  3. IDTA-defined IRIs. Where no dictionary entry exists, template authors mint identifiers in the https://admin-shell.io/idta/... namespace, for example for the template as a whole.

A consumer does not need to resolve the identifier at runtime. The point is stable string equality: if two systems both see the same semantic ID on a property, they treat the value as the same concept and can use the dictionary definition (name, unit, data type, definition text) when they need to. A tool that ignores semantic IDs and matches on idShort is quietly reintroducing the integration problem AAS was meant to remove, because idShorts are local names that vendors can and do change.

A ConceptDescription is the in-package carrier of that definition. It holds an embedded IEC 61360 data specification with preferred name, unit, data type and definition, and is addressed by the same identifier. It lets an AASX package be self-contained when the consumer has no internet access or no ECLASS licence. Licensing deserves a flag: ECLASS content is licensed; the IDTA notes and the ECLASS organisation describe the conditions, so check before you redistribute definitions in bulk.

What a template actually specifies

An IDTA submodel template is a published document plus machine-readable files (AASX, JSON, sometimes XML) that define: the submodel’s semanticId, each element’s idShort, type, semantic ID and cardinality, and any allowed values. Cardinality is expressed with qualifiers: One, ZeroToOne, OneToMany, ZeroToMany. A conformant instance must include the required elements and may include the optional ones.

Templates are versioned as major.minor.patch, and the version appears in the document name and often in the template’s semanticId (for the Digital Nameplate, the path ends in the major and minor numbers). A major version bump signals breaking structural change, so a consumer written for Nameplate 2.0 will not blindly parse 3.0. This is the practical reason to read semanticId first and branch on it.

The IDTA templates repository on GitHub lists the published set. Reviewing it in November 2026 we found a catalogue that spans these families, with the version labels the page shows:

Family Examples (version as listed)
Identification Digital Nameplate 3.0.1, Software Nameplate 1.0.1, AI Model Nameplate 1.0, Contact Information 1.0.1
Technical specification Generic Frame for Technical Data 2.0.1, Provision of 3D Models 1.0.1, Provision of Simulation Models 1.0.1 and 1.1
Documentation Handover Documentation 2.0.1, Maintenance Instructions 1.0
Structure Hierarchical Structures enabling Bills of Material 1.1.1, extension based on IEC 81346 1.0
Sustainability Carbon Footprint 1.0.1, Energy Flexibility Data Model 1.0, Digital Product Passport Part 1 1.0
Battery passport series Parts 1 to 7, from Digital Nameplate to Circularity, versions 1.0 to 1.0.1
Operations Time Series Data 1.1.1, Predictive Maintenance 1.0, Reliability 1.0.1, Service Request Notification 1.0.1
Control and interfaces Asset Interfaces Description 1.1, Control Component Type and Instance 2.0.1, Capability Description 1.0

Version labels change as the IDTA issues corrections, so treat the table as a November 2026 snapshot and re-check the templates repository before pinning a version.

Three templates worth knowing intimately

Digital Nameplate. The nameplate is the “hello world” of AAS and also the most legally relevant, because it mirrors the information that regulations require to be marked on equipment. Version 3.0 (2024) restructured the earlier ZVEI nameplate, and 3.0.1 followed in late 2025. It covers manufacturer name, product designation, product family, serial number, year of construction, address information, markings such as CE with associated files, and ordering codes. The IDTA also reuses it as Part 1 of the Digital Battery Passport template series.

Technical Data. The “Generic Frame for Technical Data for Industrial Equipment in Manufacturing” does not hard-code every property of every product. It defines a frame with general information, a product classifications section, and a technical properties section whose contents are drawn from a classification system, so a motor and a valve use the same frame but different ECLASS-defined property sets. This is a deliberate trade-off: the frame is generic, which keeps the template stable, but the meaning of a technical-data submodel depends on which classification it declares, and consumers must handle that variability.

Carbon Footprint. The Carbon Footprint template, listed at 1.0.1 in the repository, represents a product carbon footprint. It exists because Scope 3 reporting demands per-product emissions data from suppliers, and a manufacturer who can answer with a machine-readable submodel avoids a spreadsheet exchange. The IDTA’s Digital Product Passport documents reuse it, and battery passport Part 3 is a Product Carbon Footprint template. Whether the emission values are trustworthy is out of the standard’s scope; the template standardises the container, not the audit.

Do not conflate “has a Carbon Footprint submodel” with “has a verified footprint”. The submodel can carry references to a verifier or standard used, and a consuming system should require those fields before treating the numbers as reportable.

Using templates in practice

The reliable workflow has four steps. Download the template’s AASX or JSON. Open it in an editor, create an instance, and fill in values while keeping the semantic IDs untouched. Validate the instance against the metamodel schema and against the template’s cardinality rules. Publish it to a repository or package it into AASX. Skipping the second validation, the template conformance check, is the most common cause of “valid JSON, useless data”: the file loads in every tool but a downstream parser cannot find the elements it needs.

Where no published template matches your domain, you have three options in order of preference: extend a published template using its documented extension points, request a new template via the IDTA working groups, or define a company-private submodel with your own IRI namespace and be honest that it is private. Private submodels are legitimate; they just are not interoperable beyond the parties who agreed to them.

Walk-through: A Runnable AAS Example

Theory is cheaper than a running example, so here is a minimal but structurally valid AAS environment in the V3 JSON serialization. It describes a pump with a Digital Nameplate submodel. The semantic IDs follow the ECLASS pattern and the template path used by the IDTA nameplate; treat the specific IRDI strings as illustrative and confirm them against the template download before production use.

{
  "assetAdministrationShells": [
    {
      "modelType": "AssetAdministrationShell",
      "id": "https://example.com/ids/aas/pump-4711",
      "idShort": "Pump4711",
      "assetInformation": {
        "assetKind": "Instance",
        "globalAssetId": "https://example.com/ids/asset/pump-4711",
        "specificAssetIds": [
          { "name": "serialNumber", "value": "SN-2026-004711" }
        ]
      },
      "submodels": [
        {
          "type": "ModelReference",
          "keys": [
            {
              "type": "Submodel",
              "value": "https://example.com/ids/sm/nameplate/pump-4711"
            }
          ]
        }
      ]
    }
  ],
  "submodels": [
    {
      "modelType": "Submodel",
      "id": "https://example.com/ids/sm/nameplate/pump-4711",
      "idShort": "Nameplate",
      "kind": "Instance",
      "semanticId": {
        "type": "ExternalReference",
        "keys": [
          {
            "type": "GlobalReference",
            "value": "https://admin-shell.io/idta/nameplate/3/0/Nameplate"
          }
        ]
      },
      "submodelElements": [
        {
          "modelType": "MultiLanguageProperty",
          "idShort": "ManufacturerName",
          "semanticId": {
            "type": "ExternalReference",
            "keys": [
              { "type": "GlobalReference", "value": "0173-1#02-AAO677#002" }
            ]
          },
          "value": [
            { "language": "en", "text": "Example Pumps GmbH" },
            { "language": "de", "text": "Beispiel Pumpen GmbH" }
          ]
        },
        {
          "modelType": "Property",
          "idShort": "SerialNumber",
          "semanticId": {
            "type": "ExternalReference",
            "keys": [
              { "type": "GlobalReference", "value": "0173-1#02-AAM556#002" }
            ]
          },
          "valueType": "xs:string",
          "value": "SN-2026-004711"
        },
        {
          "modelType": "Property",
          "idShort": "YearOfConstruction",
          "semanticId": {
            "type": "ExternalReference",
            "keys": [
              { "type": "GlobalReference", "value": "0173-1#02-AAP906#001" }
            ]
          },
          "valueType": "xs:string",
          "value": "2026"
        }
      ]
    }
  ],
  "conceptDescriptions": []
}

Save it as pump.json. Three details are worth pausing on. The shell references the submodel by id and does not embed it. The nameplate manufacturer name is a MultiLanguageProperty because the template models it that way; sending a plain Property with the same semantic ID would parse but break conformance. And conceptDescriptions is empty, which is legal: the semantic IDs resolve against an external dictionary instead.

Validate and load it with the Eclipse BaSyx Python SDK, which exposes JSON readers in its adapter package:

from basyx.aas.adapter.json import read_aas_json_file

store = read_aas_json_file("pump.json", failsafe=True)
for obj in store:
    print(type(obj).__name__, obj.id)

With failsafe=True the reader logs problems and continues; with False it raises on the first violation, which is what you want in CI. To serve the same file over the Part 2 API, start a BaSyx AAS Environment container with the file mounted, then call it. The container image name and the preload mechanism differ between BaSyx releases, so follow the current BaSyx documentation rather than copying a command from an old blog. Once the server is up, the interesting part is how identifiers are encoded:

# base64url without padding of the submodel id
SM_ID=$(printf '%s' 'https://example.com/ids/sm/nameplate/pump-4711' \
  | base64 | tr '+/' '-_' | tr -d '=\n')

curl -s "http://localhost:8081/submodels/${SM_ID}/submodel-elements/SerialNumber/\$value"

The $value suffix returns only the value, and the \$ simply stops the shell from expanding it. If you get a 404 despite a correct id, the usual culprit is padding or standard base64 characters that were not translated to the URL-safe alphabet. A client written in Java can avoid this entirely by using the AAS4J model classes together with a generated HTTP client.

The lookup flow from discovery to value is the mental model to keep, and Figure 3 shows it.

Asset Administration Shell AAS lookup sequence through discovery, registry and submodel repository

Figure 3: Typical lookup. A consumer knows only a serial number, resolves it through discovery and the registry, then reads the nameplate with a value-only request.

In prose: the consumer asks the AAS Discovery service for shell IDs matching an asset link, such as a serial number. It then asks the AAS Registry for the shell descriptor, which lists endpoints. Finally it calls the Submodel Repository at the endpoint it found, fetching the submodel by encoded id and, for polling, requesting only values. The indirection through descriptors is what lets the shell live at the manufacturer while its submodels live at several different hosts.

AASX: Shipping a Shell as a File

AAS Part 5 specifies the AASX package format, and it is worth understanding because AASX is how most cross-company exchange still happens in 2026. An AASX is a ZIP container built on the Open Packaging Conventions (OPC, ISO/IEC 29500-2, not to be confused with OPC UA), the same packaging family used by Office documents.

Inside the ZIP you find three kinds of content:

  • The AAS serialization (JSON or XML) in a part typically placed under an aasx folder, referenced from an origin part by a relationship so a reader can find the entry point without guessing filenames.
  • Supplementary files such as PDFs, STEP files, images and certificates, referenced from File elements by their path inside the package.
  • A thumbnail and standard package metadata, so file managers can show an icon.

The practical advantages are clear: one file, no network, attachments travel with metadata. The disadvantages are equally real. AASX is a snapshot, so anything that changes (a firmware version, a live measurement) is stale the day after export. Updating one attachment means rebuilding the archive. Large archives are awkward for streaming. And because an AASX can contain executable-looking or very large files, receiving systems must scan and size-limit uploads just as with any other archive format.

Version history matters here because tooling lags. Part 5 appears in the IDTA archive at 3.0 (2023), 3.0.1 (2024) and a later 3.x revision uploaded in mid-2025. If a tool refuses an AASX, check which Part 5 and Part 1 versions it was built for before blaming the file.

A sound design rule: use AASX for type-level, slowly changing, contractual information (product family datasheet, handover documentation, certificates) and the REST API for instance-level, living information (maintenance status, operating hours). Mixing the two roles is how teams end up emailing zip files that were supposed to be live.

Tooling: What You Can Actually Run

The open-source ecosystem is unusually healthy for a standard of this size. Verified status as of the research for this article:

  • Eclipse BaSyx (Java server SDK and a Python SDK). The Java server SDK repository lists releases up to 2.0.0-milestone-15, with a milestone-8 note describing a move to metamodel 3.1; no 2.0.0 general-availability release was visible in the releases list we read. It provides containerised components, an AAS Environment, registries, discovery and a web UI. Our BaSyx hands-on tutorial walks through deploying it.
  • Eclipse AAS4J, the Java library for the metamodel: model classes plus JSON, XML and AASX serializers. The repository’s latest release at our check was 2.0.2, targeting Part 1 V3.1.
  • Eclipse AASX Package Explorer and AASX Server. The original admin-shell-io repository for the Package Explorer is archived (April 2024) and points to the Eclipse project as its home. It is a C# desktop viewer and editor, the usual tool for opening and authoring AASX files.
  • FA³ST Service from Fraunhofer, which exposes a shell through the API and can connect to OPC UA or MQTT sources. We did not re-verify its current release for this article, so check its repository before depending on it.

Selection advice: AASX Package Explorer for authoring and inspecting; BaSyx or an equivalent for hosting a repository and registry; AAS4J or the Python SDK for programmatic work; and a conformance check against the IDTA test material before you promise interoperability to a customer. Library versions track the specification with a lag of months, so a shell authored to Part 1 3.2 may need tool upgrades before it opens everywhere.

AAS vs OPC UA vs DTDL: Where Each Fits

Teams often frame the three as competitors. They are better understood as answers to different questions, and the mapping between them is a design decision rather than a conversion script. For a full treatment see our AAS vs DTDL vs OPC UA comparison; here is the condensed engineering view.

OPC UA is a communication architecture with an information model: a server exposes an address space of typed nodes, clients browse, read, write, subscribe and call methods, with a security model built in. Its strength is live, structured, secured access to a running device. Its companion specifications (for machinery, robotics, injection moulding and so on) define typed node sets for a domain, covered in our OPC UA companion specifications overview.

AAS is an information-exchange model centred on the asset lifecycle: the same shell can describe a type, an instance, a batch, a role. It is transport-agnostic, file-friendly and designed for cross-organisation hand-offs where no live connection to the device exists.

DTDL (Digital Twins Definition Language) is a JSON-LD-based modelling language used by Azure Digital Twins and some IoT Plug and Play devices. It describes interfaces made of telemetry, properties, commands, relationships and components, and it is optimised for building a queryable twin graph inside one platform.

Question AAS OPC UA DTDL
Primary job Describe and exchange asset information across companies Access a live device or server securely Model twins inside a cloud graph
Typical form Shell, submodels, AASX file or REST API Address space of typed nodes JSON-LD interface definitions
Semantics semanticId to ECLASS, CDD, IDTA IRIs Companion spec types, optional dictionary references Model identifiers in a DTMI namespace
Offline hand-over Strong, via AASX Weak, needs a running server Weak, platform bound
Live telemetry Possible but not its focus Native, with subscriptions Native in the host platform
Lifecycle kinds Type, instance, batch, role Instance oriented Model and twin instance

The official bridge between the first two is the OPC UA companion specification OPC 30270, “Industry 4.0 Asset Administration Shell” (I4AAS), which defines how AAS metamodel concepts map to OPC UA ObjectTypes and DataTypes. The OPC Foundation reference page lists release 1.00 dated June 2021; whether a later release exists should be confirmed on that page. Because the OPC UA version mirrors an older metamodel line, expect a gap between it and AAS V3 and verify support before relying on it.

AAS, OPC UA and DTDL mapping gateway from a machine to partner and internal consumers

Figure 4: A common dual-publication pattern. OPC UA stays the live interface to the machine; a gateway publishes the same facts as an AAS for partners and as a DTDL twin for internal analytics.

The pattern in Figure 4 is the one we recommend for brownfield plants. Keep OPC UA as the system of record for live values, because it already carries security, subscriptions and quality codes. Generate the AAS operational submodel from OPC UA nodes through a mapping table in which each submodel element has a semantic ID and a source node ID. Generate the DTDL model from the same table when an internal cloud platform needs it. One mapping table, three renderings.

Mapping decisions that matter

Units are the first trap. OPC UA carries engineering units in an EUInformation property using UN/CEFACT codes; AAS conveys unit through the data specification of the concept description; DTDL uses a semantic type with unit. Normalise to one canonical unit at the gateway and document it, otherwise a 50 versus 0.05 discrepancy will appear in some downstream report.

Identity is the second. An OPC UA node ID is local to a server namespace, whereas an AAS id must be globally unique and stable. If you derive the shell id from an IP address or a hostname, every re-commission breaks references. Derive it from the asset’s own identity, such as manufacturer plus serial number.

History is the third. Neither the AAS metamodel nor DTDL is a time-series store. The AAS Time Series Data template (version 1.1.1 in the repository listing) describes how to expose series, typically by linking to an external store or embedding segments. Use it as a pointer, not as a historian. Our write-up on bringing OPC UA historian data into a digital twin covers the ingestion side.

Trade-offs, Gotchas, and What Goes Wrong

AAS adoption fails in predictable ways, and most of them are about people and process rather than the specification.

Template drift. A supplier fills Nameplate 2.0, a customer’s parser expects 3.0, and nothing errors because both are valid JSON. Defence: log the submodel semanticId on ingest, whitelist the versions you accept, and reject the rest loudly.

idShort matching. Developers under time pressure write get("SerialNumber") instead of resolving by semantic ID. It works with one supplier and fails with the second, who calls it SerNo. Defence: build a small resolver that finds elements by semantic ID and treat idShort as display text.

Giant submodels. Technical Data for a complex drive can run to hundreds of elements, and Hierarchical Structures for a whole machine BOM can be larger still. Fetching the whole thing to read one value wastes bandwidth. Defence: use $value, level=core, path-based element addressing, and pagination, and split very large content into several submodels.

Treating the AAS as the database. Repositories are optimised for document-like access. Pushing 1 kHz sensor streams into properties will saturate the server and produce a useless audit trail. Defence: keep high-rate data in a time-series store and reference it.

Security gaps. The API is a normal HTTP surface. An unauthenticated repository leaks nameplates, BOMs and sometimes configuration parameters that make attacks easier. Part 4’s access rules are expressive, but implementation coverage varies between products, so test authorisation, not just authentication. Reverse proxies with OAuth 2.0 and mutual TLS remain a pragmatic baseline.

Registry staleness. If shells move and descriptors are not updated, consumers receive dead endpoints. The 3.1 API added bulk registry operations, which help migrations; make descriptor updates part of the deployment pipeline.

Spec version skew. Part 1 has had a steady cadence of corrections (3.0 through 3.1.2, then 3.2), the API has its own numbering, and tools support different combinations. A package produced by a new editor can fail to import in an older server. Defence: pin versions in your contracts, and run an import test in CI against the lowest version a partner uses.

Overstated maturity claims. The type 3 “proactive” shell, with shells negotiating autonomously in a standardised language, is not something you can buy as a product today. We found no evidence of a mainstream production deployment, and we advise treating vendor claims of it sceptically. That is an opinion; ask for a live demonstration.

Licensing and governance. ECLASS dictionary content is licensed; IDTA documents carry their own terms. Teams that scrape and redistribute definitions have been surprised later. Read the terms before bundling.

None of these is fatal. Each has a cheap mitigation, provided it is considered before the first supplier integration rather than after the tenth.

Practical Recommendations

If you are starting now, resist the temptation to model everything. The most successful programmes begin with one product family, two or three published templates, and a clear consumer who will act on the data. A sensible path looks like this.

First, pick templates before you pick software. Start with Digital Nameplate and Handover Documentation because they are broadly applicable and have an obvious reader (service teams, procurement). Add Technical Data once you have decided on a classification system, and add Carbon Footprint or the passport templates if a customer or regulator is asking. Resist inventing private submodels until you have confirmed no published template fits.

Second, decide the exchange mode per data class. Contractual, type-level data goes into AASX files attached to orders and published on a portal. Instance-level, changing data goes behind an authenticated REST API through a repository and registry. Live telemetry stays on OPC UA or MQTT and is linked, not copied.

Third, make identity deliberate. Define how asset IDs and shell IDs are minted, who owns the namespace, and how serial numbers map to specific asset IDs for discovery. This is a governance task, not a coding one, and it is the step most often postponed.

Fourth, automate conformance. Validate every outgoing file against the metamodel schema and the template cardinalities, and run consumer-side tests against a sample from each supplier.

A short checklist:

  • [ ] Selected template versions pinned and recorded, with semantic IDs whitelisted.
  • [ ] Shell and asset ID scheme documented and collision-free.
  • [ ] Parsers resolve by semantic ID, never by idShort alone.
  • [ ] AASX used for type data, API for instance data, OPC UA or MQTT for live data.
  • [ ] Authentication and authorisation tested on every repository endpoint.
  • [ ] Registry and discovery updates built into deployment pipelines.
  • [ ] CI imports a package from the oldest specification version a partner uses.
  • [ ] Dictionary licensing reviewed.

For regulated products, read the DPP guidance next. Our Digital Product Passport architecture piece explains how the passport requirements land on top of these building blocks.

Frequently Asked Questions

What is the Asset Administration Shell in simple terms?

It is a standardized digital envelope for an asset. The shell holds identity information and references to submodels, each covering one aspect such as nameplate, technical data or maintenance. Elements carry semantic IDs, so software knows what each value means. The shell can be exchanged as an AASX file or served through a REST API, and it is the IEC 63278 and IDTA answer to proprietary equipment data formats in Industry 4.0 networks.

What is the difference between an AAS and a submodel?

The shell identifies one asset and lists which aspects exist; it holds few facts itself. A submodel is one aspect, such as the Digital Nameplate, containing the actual elements and values. Submodels can be hosted separately from the shell, can be reused across assets, and follow templates identified by a semantic ID. In short, the shell is the index card and the submodels are the chapters.

Which AAS specification version should I use in 2026?

Use the metamodel and API versions your partners and tools support, which for most projects means the 3.x line. The IDTA archive lists Part 1 at 3.1.2 from late 2025 and a 3.2 document from July 2026, with Part 2 at 3.1.x. Check library support first: AAS4J’s repository states support for V3.1, so a 3.2-only feature may need a newer tool. Pin the versions in contracts.

How is AAS different from OPC UA?

OPC UA is a secured, live communication protocol with typed address spaces; AAS is an information-exchange model for describing assets across their lifecycle and between companies, usable without a connection to the device. They complement each other. A common pattern keeps OPC UA as the live interface and publishes selected data as AAS submodels, with OPC 30270 defining a standard mapping between the two.

What is an AASX file?

An AASX file is a ZIP package, based on the Open Packaging Conventions, that bundles an AAS serialization in JSON or XML with supplementary files such as manuals, CAD models and certificates. It is defined in Part 5 of the AAS specification. It is ideal for type-level, slowly changing information handed to a customer, but it is a snapshot and not suitable for live data.

Where do I find the IDTA submodel templates?

The IDTA publishes them on its content hub and in the open admin-shell-io submodel-templates GitHub repository, listing families such as Digital Nameplate, Technical Data, Carbon Footprint, Handover Documentation, Time Series Data and the Digital Battery Passport series. Each template ships as a PDF specification plus machine-readable files. Always confirm the current version before use, because patch releases change often.

Further Reading

Internal guides on this site:

External primary sources:

Last updated November 2026.

By Riju — about

1 Comment

Leave a Reply

Your email address will not be published. Required fields are marked *