ArchiMate 3.2 vs. ArchiMate 4.0

ArchiMate 3.2 vs. ArchiMate 4.0: A Structured Analysis of Specification Changes

With the release of the ArchiMate® 4.0 Specification by The Open Group in April 2026, the widely used modeling language for Enterprise Architecture undergoes its most comprehensive revision to date. While ArchiMate 3.2 (released in 2022) was still based on the concept of “Layers” and a matrix-based framework, version 4.0 introduces a fundamental restructuring. The goal of this change is to simplify the language, remove redundancies, and increase its applicability across various domains.

Since version 4.0 was only recently published, broad practical experience or case studies are not yet available. The following analysis is based exclusively on the facts from the two specification documents and describes the structural and conceptual differences – visualized through comparative diagrams.

1. The Core Scope: From Core Framework to Core Language

The most significant difference between the versions lies in the organization of the language’s fundamental building blocks.

ArchiMate 3.2: The Core Framework (Layers and Aspects)

In version 3.2, the language is strictly hierarchically divided into Layers and Aspects. This results in the well-known 3x3 grid. Each element is firmly tied to a layer, leading to a duplication of concepts (e.g., there is a Business Process, an Application Process, and a Technology Process as separate elements).

graph TD
    subgraph V3.2 ["ArchiMate 3.2: Core Framework (Matrix)"]
        direction TB
        subgraph Layer_B ["Business Layer"]
            B_Act[Business Actor/Role]
            B_Beh[Business Process/Function]
            B_Pass[Business Object]
        end
        subgraph Layer_A ["Application Layer"]
            A_Act[Application Component]
            A_Beh[Application Process/Function]
            A_Pass[Data Object]
        end
        subgraph Layer_T ["Technology Layer"]
            T_Act[Node/Device]
            T_Beh[Tech Process/Function]
            T_Pass[Artifact/Material]
        end
        
        B_Act --- B_Beh --- B_Pass
        A_Act --- A_Beh --- A_Pass
        T_Act --- T_Beh --- T_Pass
        
        style B_Act fill:#ffe6cc,stroke:#d79b00
        style A_Act fill:#dae8fc,stroke:#6c8ebf
        style T_Act fill:#d5e8d4,stroke:#82b366
    end

    note["Each layer has its own, duplicated elements for structure, behavior, and passive objects."]
    note -.- V3.2

ArchiMate 4.0: The Core Language (Domains and Generic Elements)

Version 4.0 dissolves the rigid layer matrix. The centerpiece is now the Common Domain, which provides generic elements. The domain-specific elements (Business, Application, Technology) are defined as specializations of these generic elements.

graph TD
    subgraph V4 ["ArchiMate 4.0: Core Language (Common Domain)"]
        direction TB
        
        subgraph Common ["Common Domain (Generic)"]
            Gen_Act[Role / Collaboration]
            Gen_Beh[Process / Function / Service / Event]
            Gen_Pass[Passive Structure Element]
            
            Gen_Act -->|Assignment| Gen_Beh
            Gen_Beh -->|Access| Gen_Pass
        end
        
        subgraph Specs ["Domain Specializations"]
            Biz["Business Domain<br/>(e.g. Business Actor, Business Process)"]
            App["Application Domain<br/>(e.g. App Component, App Process)"]
            Tech["Technology Domain<br/>(e.g. Node, Tech Process)"]
        end
        
        Biz -.->|Specializes| Gen_Act
        Biz -.->|Specializes| Gen_Beh
        App -.->|Specializes| Gen_Act
        App -.->|Specializes| Gen_Beh
        Tech -.->|Specializes| Gen_Act
        Tech -.->|Specializes| Gen_Beh
        
        style Common fill:#f5f5f5,stroke:#333,stroke-width:2px
        style Gen_Beh fill:#fff4cc,stroke:#d6b656
        style Gen_Act fill:#ffe6cc,stroke:#d79b00
        style Gen_Pass fill:#e1d5e7,stroke:#9673a6
    end

    note4["Unified elements in the core. Domains now only define context/specialization."]
    note4 -.- V4

Core Summary: ArchiMate 3.2 defines elements in a layer-specific manner (redundancy). ArchiMate 4.0 defines elements generically in a Common Domain and uses domains for contextual assignment.

2. The Full Scope: From Full Framework to Full Language

Expanding the view to the entire language reveals further profound changes in structure and element inventory.

2.1 Structural Change: From Matrix to Hexagonion

While 3.2 represents the language as an extended matrix, 4.0 uses the concept of the “ArchiMate Hexagonion”, where domains are arranged as connected fields around a core (Common/Motivation).

flowchart LR
    subgraph V3_Struct ["V3.2 Structure: Stacked Layers"]
        direction TB
        L_Mot[Motivation Extension]
        L_Strat[Strategy Layer]
        L_Bus[Business Layer]
        L_App[Application Layer]
        L_Tech[Technology Layer]
        L_Mig[Impl. & Migration Layer]
        
        L_Mot --- L_Strat --- L_Bus --- L_App --- L_Tech --- L_Mig
    end

    subgraph V4_Struct ["V4.0 Structure: Domain Network"]
        direction LR
        D_Mot((Motivation))
        D_Strat((Strategy))
        D_Com((Common Domain))
        D_Bus((Business))
        D_App((Application))
        D_Tech((Technology))
        D_Mig((Impl. & Migration))
        
        D_Mot --- D_Strat
        D_Strat --- D_Com
        D_Com --- D_Bus
        D_Com --- D_App
        D_Com --- D_Tech
        D_Com --- D_Mig
        D_Bus --- D_App
        D_App --- D_Tech
    end
    
    V3_Struct ~~~ V4_Struct

2.2 Element Consolidation: What Was Removed?

A distinctive feature of version 4.0 is the removal of several specific elements. These concepts were not deleted but transferred into more generic elements (specialization).

mindmap
  root((ArchiMate 4.0<br/>Element Consolidation))
    Behavior
      Interactions removed
      :: icon(fa fa-trash)
      Now: Specialized Processes/Functions
    Structure
      Contract removed
      :: icon(fa fa-file-contract)
      Now: Specialized Business Object
      Representation removed
      :: icon(fa fa-image)
      Now: Specialized Data Object/Artifact
    Motivation
      Constraint removed
      :: icon(fa fa-ban)
      Now: Specialized Requirement
      Gap removed
      :: icon(fa fa-hole)
      Now: Specialized Assessment/Deliverable
    Migration
      Impl. Event removed
      :: icon(fa fa-flag)
      Now: Generic Event

2.3 New Capabilities: Multiplicity

A long-requested feature arrives in version 4.0: Multiplicities. While 3.2 only knew type relationships, 4.0 now allows the definition of instance sets at the ends of a relationship.

classDiagram
    class ArchiMate_3_2 {
        +Relationship: Source -- Target
        +Multiplicity: Not supported
    }
    
    class ArchiMate_4_0 {
        +Relationship: Source -- Target
        +Multiplicity: Supported (e.g., 1..*, 0..1)
        +Example: Customer "1" -- "0..*" Order
    }
    
    ArchiMate_3_2 ..> ArchiMate_4_0 : Evolution

Conclusion

The transition from ArchiMate 3.2 to 4.0 represents a paradigm shift: away from a layer-oriented, element-rich language towards a domain-oriented, generalized, and leaner language.

• Advantages of 4.0: Through the Common Domain, the language becomes more consistent and easier to extend. The reduction of specific elements (such as Interaction or Constraint) follows the principle of “Simplicity over Comprehensiveness.” The introduction of multiplicities significantly increases precision in modeling.
• Challenges: The strict layer separation of 3.2 offered a certain visual orientation, which is replaced in 4.0 by more abstract domain assignments. Existing models must be migrated, as elements like Contract or Interaction no longer exist technically as primitive types.
• Status: Since version 4.0 was only released in April 2026, the current focus is on the theoretical specification. Tool support and proven modeling patterns for the new Common Domain still need to prove themselves in practice.

ArchiMate 4.0 is a consistent attempt to future-proof the language through reduction and generalization. Whether the “Hexagonion” will prevail in practice against the proven 3x3 grid remains to be seen in the coming times.

• ←Previous
• Next→