diff --git a/backends/arm/BUCK b/backends/arm/BUCK
index 95092effd7c..4efbdf6c69b 100644
--- a/backends/arm/BUCK
+++ b/backends/arm/BUCK
@@ -84,6 +84,7 @@ fbcode_target(
         "ethosu/__init__.py",
         "ethosu/backend.py",
         "ethosu/compile_spec.py",
+        "ethosu/parse_delegate_metadata.py",
         "ethosu/partitioner.py",
     ],
     deps = [
diff --git a/backends/arm/CMakeLists.txt b/backends/arm/CMakeLists.txt
index 69ec45ccd17..15371937dd4 100644
--- a/backends/arm/CMakeLists.txt
+++ b/backends/arm/CMakeLists.txt
@@ -100,7 +100,9 @@ if(EXECUTORCH_BUILD_ARM_BAREMETAL OR EXECUTORCH_BUILD_ARM_ETHOSU_LINUX)
     target_include_directories(
       ethosu_execution_stats PRIVATE ${DRIVER_ETHOSU_INCLUDE_DIR}
     )
-    target_link_libraries(ethosu_execution_stats PUBLIC ethosu_core_driver)
+    target_link_libraries(
+      ethosu_execution_stats PUBLIC ethosu_core_driver executorch_core
+    )
   elseif(EXECUTORCH_BUILD_ARM_ETHOSU_LINUX)
     target_sources(
       executorch_delegate_ethos_u
diff --git a/backends/arm/ethosu/parse_delegate_metadata.py b/backends/arm/ethosu/parse_delegate_metadata.py
new file mode 100644
index 00000000000..100e6981031
--- /dev/null
+++ b/backends/arm/ethosu/parse_delegate_metadata.py
@@ -0,0 +1,441 @@
+# Copyright 2026 Arm Limited and/or its affiliates.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+"""Decode experimental Ethos-U PMU metadata from ETDump profile events.
+
+The wire format and public Python types may change without compatibility
+support.
+
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import IntEnum
+from struct import Struct
+from typing import Any, Sequence
+
+_HEADER = Struct("<4sIIIIQQI")
+_COUNTER = Struct("<IQI")
+_MAGIC_PREFIX = b"EUC"
+_MAX_COUNTERS = 8
+
+
+class EthosUProduct(IntEnum):
+    """Product IDs from core_driver/include/ethosu_types.h."""
+
+    U55 = 0
+    U65 = 1
+    U85 = 2
+
+
+class EthosUPlatform(IntEnum):
+    """Platform IDs from EthosUExecutionStats.h."""
+
+    CoreDriver = 0
+
+
+class EthosUPmuEvent(IntEnum):
+    """Symbolic IDs from core_driver/include/ethosu_pmu_types.h.
+
+    Values mirror the order of the core driver's ethosu_pmu_event_type enum.
+
+    """
+
+    ETHOSU_PMU_AO_ACTIVE = 0
+    ETHOSU_PMU_AO_ACTIVE_16BIT = 1
+    ETHOSU_PMU_AO_ACTIVE_8BIT = 2
+    ETHOSU_PMU_AO_STALLED_BY_AB = 3
+    ETHOSU_PMU_AO_STALLED_BY_AB_OR_CB = 4
+    ETHOSU_PMU_AO_STALLED_BY_ACC = 5
+    ETHOSU_PMU_AO_STALLED_BY_ACC_IB = 6
+    ETHOSU_PMU_AO_STALLED_BY_BS = 7
+    ETHOSU_PMU_AO_STALLED_BY_BS_OR_OB = 8
+    ETHOSU_PMU_AO_STALLED_BY_CB = 9
+    ETHOSU_PMU_AO_STALLED_BY_IB = 10
+    ETHOSU_PMU_AO_STALLED_BY_OB = 11
+    ETHOSU_PMU_AO_STALLED_BY_OFMP = 12
+    ETHOSU_PMU_AO_STALLED_BY_OFMP_OB = 13
+    ETHOSU_PMU_AXI0_ENABLED_CYCLES = 14
+    ETHOSU_PMU_AXI0_RD_DATA_BEAT_RECEIVED = 15
+    ETHOSU_PMU_AXI0_RD_STALL_LIMIT = 16
+    ETHOSU_PMU_AXI0_RD_TRANS_ACCEPTED = 17
+    ETHOSU_PMU_AXI0_RD_TRANS_COMPLETED = 18
+    ETHOSU_PMU_AXI0_RD_TRAN_REQ_STALLED = 19
+    ETHOSU_PMU_AXI0_WR_DATA_BEAT_STALLED = 20
+    ETHOSU_PMU_AXI0_WR_DATA_BEAT_WRITTEN = 21
+    ETHOSU_PMU_AXI0_WR_STALL_LIMIT = 22
+    ETHOSU_PMU_AXI0_WR_TRANS_ACCEPTED = 23
+    ETHOSU_PMU_AXI0_WR_TRANS_COMPLETED_M = 24
+    ETHOSU_PMU_AXI0_WR_TRANS_COMPLETED_S = 25
+    ETHOSU_PMU_AXI0_WR_TRAN_REQ_STALLED = 26
+    ETHOSU_PMU_AXI1_ENABLED_CYCLES = 27
+    ETHOSU_PMU_AXI1_RD_DATA_BEAT_RECEIVED = 28
+    ETHOSU_PMU_AXI1_RD_STALL_LIMIT = 29
+    ETHOSU_PMU_AXI1_RD_TRANS_ACCEPTED = 30
+    ETHOSU_PMU_AXI1_RD_TRANS_COMPLETED = 31
+    ETHOSU_PMU_AXI1_RD_TRAN_REQ_STALLED = 32
+    ETHOSU_PMU_AXI1_WR_DATA_BEAT_STALLED = 33
+    ETHOSU_PMU_AXI1_WR_DATA_BEAT_WRITTEN = 34
+    ETHOSU_PMU_AXI1_WR_STALL_LIMIT = 35
+    ETHOSU_PMU_AXI1_WR_TRANS_ACCEPTED = 36
+    ETHOSU_PMU_AXI1_WR_TRANS_COMPLETED_M = 37
+    ETHOSU_PMU_AXI1_WR_TRANS_COMPLETED_S = 38
+    ETHOSU_PMU_AXI1_WR_TRAN_REQ_STALLED = 39
+    ETHOSU_PMU_AXI_LATENCY_1024 = 40
+    ETHOSU_PMU_AXI_LATENCY_128 = 41
+    ETHOSU_PMU_AXI_LATENCY_256 = 42
+    ETHOSU_PMU_AXI_LATENCY_32 = 43
+    ETHOSU_PMU_AXI_LATENCY_512 = 44
+    ETHOSU_PMU_AXI_LATENCY_64 = 45
+    ETHOSU_PMU_AXI_LATENCY_ANY = 46
+    ETHOSU_PMU_CC_STALLED_ON_BLOCKDEP = 47
+    ETHOSU_PMU_CC_STALLED_ON_SHRAM_RECONFIG = 48
+    ETHOSU_PMU_CYCLE = 49
+    ETHOSU_PMU_ECC_AO_CB = 50
+    ETHOSU_PMU_ECC_AO_LUT = 51
+    ETHOSU_PMU_ECC_AO_OB = 52
+    ETHOSU_PMU_ECC_DMA = 53
+    ETHOSU_PMU_ECC_MAC_AB = 54
+    ETHOSU_PMU_ECC_MAC_IB = 55
+    ETHOSU_PMU_ECC_SB0 = 56
+    ETHOSU_PMU_ECC_SB1 = 57
+    ETHOSU_PMU_EXT0_ENABLED_CYCLES = 58
+    ETHOSU_PMU_EXT0_RD_DATA_BEAT_RECEIVED = 59
+    ETHOSU_PMU_EXT0_RD_STALL_LIMIT = 60
+    ETHOSU_PMU_EXT0_RD_TRANS_ACCEPTED = 61
+    ETHOSU_PMU_EXT0_RD_TRANS_COMPLETED = 62
+    ETHOSU_PMU_EXT0_RD_TRAN_REQ_STALLED = 63
+    ETHOSU_PMU_EXT0_WR_DATA_BEAT_STALLED = 64
+    ETHOSU_PMU_EXT0_WR_DATA_BEAT_WRITTEN = 65
+    ETHOSU_PMU_EXT0_WR_STALL_LIMIT = 66
+    ETHOSU_PMU_EXT0_WR_TRANS_ACCEPTED = 67
+    ETHOSU_PMU_EXT0_WR_TRANS_COMPLETED_M = 68
+    ETHOSU_PMU_EXT0_WR_TRANS_COMPLETED_S = 69
+    ETHOSU_PMU_EXT0_WR_TRAN_REQ_STALLED = 70
+    ETHOSU_PMU_EXT1_ENABLED_CYCLES = 71
+    ETHOSU_PMU_EXT1_RD_DATA_BEAT_RECEIVED = 72
+    ETHOSU_PMU_EXT1_RD_STALL_LIMIT = 73
+    ETHOSU_PMU_EXT1_RD_TRANS_ACCEPTED = 74
+    ETHOSU_PMU_EXT1_RD_TRANS_COMPLETED = 75
+    ETHOSU_PMU_EXT1_RD_TRAN_REQ_STALLED = 76
+    ETHOSU_PMU_EXT1_WR_DATA_BEAT_STALLED = 77
+    ETHOSU_PMU_EXT1_WR_DATA_BEAT_WRITTEN = 78
+    ETHOSU_PMU_EXT1_WR_STALL_LIMIT = 79
+    ETHOSU_PMU_EXT1_WR_TRANS_ACCEPTED = 80
+    ETHOSU_PMU_EXT1_WR_TRANS_COMPLETED_M = 81
+    ETHOSU_PMU_EXT1_WR_TRANS_COMPLETED_S = 82
+    ETHOSU_PMU_EXT1_WR_TRAN_REQ_STALLED = 83
+    ETHOSU_PMU_EXT_ENABLED_CYCLES = 84
+    ETHOSU_PMU_EXT_RD_DATA_BEAT_RECEIVED = 85
+    ETHOSU_PMU_EXT_RD_STALL_LIMIT = 86
+    ETHOSU_PMU_EXT_RD_TRANS_ACCEPTED = 87
+    ETHOSU_PMU_EXT_RD_TRANS_COMPLETED = 88
+    ETHOSU_PMU_EXT_RD_TRAN_REQ_STALLED = 89
+    ETHOSU_PMU_EXT_WR_DATA_BEAT_STALLED = 90
+    ETHOSU_PMU_EXT_WR_DATA_BEAT_WRITTEN = 91
+    ETHOSU_PMU_EXT_WR_STALL_LIMIT = 92
+    ETHOSU_PMU_EXT_WR_TRANS_ACCEPTED = 93
+    ETHOSU_PMU_EXT_WR_TRANS_COMPLETED_M = 94
+    ETHOSU_PMU_EXT_WR_TRANS_COMPLETED_S = 95
+    ETHOSU_PMU_EXT_WR_TRAN_REQ_STALLED = 96
+    ETHOSU_PMU_MAC_ACTIVE = 97
+    ETHOSU_PMU_MAC_ACTIVE_16BIT = 98
+    ETHOSU_PMU_MAC_ACTIVE_32BIT = 99
+    ETHOSU_PMU_MAC_ACTIVE_8BIT = 100
+    ETHOSU_PMU_MAC_DPU_ACTIVE = 101
+    ETHOSU_PMU_MAC_STALLED_BY_ACC = 102
+    ETHOSU_PMU_MAC_STALLED_BY_IB = 103
+    ETHOSU_PMU_MAC_STALLED_BY_INT_ACC = 104
+    ETHOSU_PMU_MAC_STALLED_BY_INT_W = 105
+    ETHOSU_PMU_MAC_STALLED_BY_W = 106
+    ETHOSU_PMU_MAC_STALLED_BY_WD = 107
+    ETHOSU_PMU_MAC_STALLED_BY_WD_ACC = 108
+    ETHOSU_PMU_MAC_STALLED_BY_W_OR_ACC = 109
+    ETHOSU_PMU_NO_EVENT = 110
+    ETHOSU_PMU_NPU_ACTIVE = 111
+    ETHOSU_PMU_NPU_IDLE = 112
+    ETHOSU_PMU_SRAM0_ENABLED_CYCLES = 113
+    ETHOSU_PMU_SRAM0_RD_DATA_BEAT_RECEIVED = 114
+    ETHOSU_PMU_SRAM0_RD_STALL_LIMIT = 115
+    ETHOSU_PMU_SRAM0_RD_TRANS_ACCEPTED = 116
+    ETHOSU_PMU_SRAM0_RD_TRANS_COMPLETED = 117
+    ETHOSU_PMU_SRAM0_RD_TRAN_REQ_STALLED = 118
+    ETHOSU_PMU_SRAM0_WR_DATA_BEAT_STALLED = 119
+    ETHOSU_PMU_SRAM0_WR_DATA_BEAT_WRITTEN = 120
+    ETHOSU_PMU_SRAM0_WR_STALL_LIMIT = 121
+    ETHOSU_PMU_SRAM0_WR_TRANS_ACCEPTED = 122
+    ETHOSU_PMU_SRAM0_WR_TRANS_COMPLETED_M = 123
+    ETHOSU_PMU_SRAM0_WR_TRANS_COMPLETED_S = 124
+    ETHOSU_PMU_SRAM0_WR_TRAN_REQ_STALLED = 125
+    ETHOSU_PMU_SRAM1_ENABLED_CYCLES = 126
+    ETHOSU_PMU_SRAM1_RD_DATA_BEAT_RECEIVED = 127
+    ETHOSU_PMU_SRAM1_RD_STALL_LIMIT = 128
+    ETHOSU_PMU_SRAM1_RD_TRANS_ACCEPTED = 129
+    ETHOSU_PMU_SRAM1_RD_TRANS_COMPLETED = 130
+    ETHOSU_PMU_SRAM1_RD_TRAN_REQ_STALLED = 131
+    ETHOSU_PMU_SRAM1_WR_DATA_BEAT_STALLED = 132
+    ETHOSU_PMU_SRAM1_WR_DATA_BEAT_WRITTEN = 133
+    ETHOSU_PMU_SRAM1_WR_STALL_LIMIT = 134
+    ETHOSU_PMU_SRAM1_WR_TRANS_ACCEPTED = 135
+    ETHOSU_PMU_SRAM1_WR_TRANS_COMPLETED_M = 136
+    ETHOSU_PMU_SRAM1_WR_TRANS_COMPLETED_S = 137
+    ETHOSU_PMU_SRAM1_WR_TRAN_REQ_STALLED = 138
+    ETHOSU_PMU_SRAM2_ENABLED_CYCLES = 139
+    ETHOSU_PMU_SRAM2_RD_DATA_BEAT_RECEIVED = 140
+    ETHOSU_PMU_SRAM2_RD_STALL_LIMIT = 141
+    ETHOSU_PMU_SRAM2_RD_TRANS_ACCEPTED = 142
+    ETHOSU_PMU_SRAM2_RD_TRANS_COMPLETED = 143
+    ETHOSU_PMU_SRAM2_RD_TRAN_REQ_STALLED = 144
+    ETHOSU_PMU_SRAM2_WR_DATA_BEAT_STALLED = 145
+    ETHOSU_PMU_SRAM2_WR_DATA_BEAT_WRITTEN = 146
+    ETHOSU_PMU_SRAM2_WR_STALL_LIMIT = 147
+    ETHOSU_PMU_SRAM2_WR_TRANS_ACCEPTED = 148
+    ETHOSU_PMU_SRAM2_WR_TRANS_COMPLETED_M = 149
+    ETHOSU_PMU_SRAM2_WR_TRANS_COMPLETED_S = 150
+    ETHOSU_PMU_SRAM2_WR_TRAN_REQ_STALLED = 151
+    ETHOSU_PMU_SRAM3_ENABLED_CYCLES = 152
+    ETHOSU_PMU_SRAM3_RD_DATA_BEAT_RECEIVED = 153
+    ETHOSU_PMU_SRAM3_RD_STALL_LIMIT = 154
+    ETHOSU_PMU_SRAM3_RD_TRANS_ACCEPTED = 155
+    ETHOSU_PMU_SRAM3_RD_TRANS_COMPLETED = 156
+    ETHOSU_PMU_SRAM3_RD_TRAN_REQ_STALLED = 157
+    ETHOSU_PMU_SRAM3_WR_DATA_BEAT_STALLED = 158
+    ETHOSU_PMU_SRAM3_WR_DATA_BEAT_WRITTEN = 159
+    ETHOSU_PMU_SRAM3_WR_STALL_LIMIT = 160
+    ETHOSU_PMU_SRAM3_WR_TRANS_ACCEPTED = 161
+    ETHOSU_PMU_SRAM3_WR_TRANS_COMPLETED_M = 162
+    ETHOSU_PMU_SRAM3_WR_TRANS_COMPLETED_S = 163
+    ETHOSU_PMU_SRAM3_WR_TRAN_REQ_STALLED = 164
+    ETHOSU_PMU_SRAM_ENABLED_CYCLES = 165
+    ETHOSU_PMU_SRAM_RD_DATA_BEAT_RECEIVED = 166
+    ETHOSU_PMU_SRAM_RD_STALL_LIMIT = 167
+    ETHOSU_PMU_SRAM_RD_TRANS_ACCEPTED = 168
+    ETHOSU_PMU_SRAM_RD_TRANS_COMPLETED = 169
+    ETHOSU_PMU_SRAM_RD_TRAN_REQ_STALLED = 170
+    ETHOSU_PMU_SRAM_WR_DATA_BEAT_STALLED = 171
+    ETHOSU_PMU_SRAM_WR_DATA_BEAT_WRITTEN = 172
+    ETHOSU_PMU_SRAM_WR_STALL_LIMIT = 173
+    ETHOSU_PMU_SRAM_WR_TRANS_ACCEPTED = 174
+    ETHOSU_PMU_SRAM_WR_TRANS_COMPLETED_M = 175
+    ETHOSU_PMU_SRAM_WR_TRANS_COMPLETED_S = 176
+    ETHOSU_PMU_SRAM_WR_TRAN_REQ_STALLED = 177
+    ETHOSU_PMU_WD_ACTIVE = 178
+    ETHOSU_PMU_WD_PARSE_ACTIVE = 179
+    ETHOSU_PMU_WD_PARSE_ACTIVE_SC0 = 180
+    ETHOSU_PMU_WD_PARSE_ACTIVE_SC1 = 181
+    ETHOSU_PMU_WD_PARSE_ACTIVE_SC2 = 182
+    ETHOSU_PMU_WD_PARSE_ACTIVE_SC3 = 183
+    ETHOSU_PMU_WD_PARSE_STALLED = 184
+    ETHOSU_PMU_WD_PARSE_STALLED_IN = 185
+    ETHOSU_PMU_WD_PARSE_STALLED_OUT = 186
+    ETHOSU_PMU_WD_PARSE_STALL_IN_SC0 = 187
+    ETHOSU_PMU_WD_PARSE_STALL_IN_SC1 = 188
+    ETHOSU_PMU_WD_PARSE_STALL_IN_SC2 = 189
+    ETHOSU_PMU_WD_PARSE_STALL_IN_SC3 = 190
+    ETHOSU_PMU_WD_PARSE_STALL_OUT_SC0 = 191
+    ETHOSU_PMU_WD_PARSE_STALL_OUT_SC1 = 192
+    ETHOSU_PMU_WD_PARSE_STALL_OUT_SC2 = 193
+    ETHOSU_PMU_WD_PARSE_STALL_OUT_SC3 = 194
+    ETHOSU_PMU_WD_PARSE_STALL_SC0 = 195
+    ETHOSU_PMU_WD_PARSE_STALL_SC1 = 196
+    ETHOSU_PMU_WD_PARSE_STALL_SC2 = 197
+    ETHOSU_PMU_WD_PARSE_STALL_SC3 = 198
+    ETHOSU_PMU_WD_STALLED = 199
+    ETHOSU_PMU_WD_STALLED_BY_WD_BUF = 200
+    ETHOSU_PMU_WD_STALLED_BY_WS = 201
+    ETHOSU_PMU_WD_STALLED_BY_WS_FC = 202
+    ETHOSU_PMU_WD_STALLED_BY_WS_SC0 = 203
+    ETHOSU_PMU_WD_STALLED_BY_WS_SC1 = 204
+    ETHOSU_PMU_WD_STALLED_BY_WS_SC2 = 205
+    ETHOSU_PMU_WD_STALLED_BY_WS_SC3 = 206
+    ETHOSU_PMU_WD_STALLED_BY_WS_TC = 207
+    ETHOSU_PMU_WD_TRANS_DW0 = 208
+    ETHOSU_PMU_WD_TRANS_DW1 = 209
+    ETHOSU_PMU_WD_TRANS_WB = 210
+    ETHOSU_PMU_WD_TRANS_WB0 = 211
+    ETHOSU_PMU_WD_TRANS_WB1 = 212
+    ETHOSU_PMU_WD_TRANS_WB2 = 213
+    ETHOSU_PMU_WD_TRANS_WB3 = 214
+    ETHOSU_PMU_WD_TRANS_WBLK = 215
+    ETHOSU_PMU_WD_TRANS_WS = 216
+    ETHOSU_PMU_WD_TRANS_WS_FC = 217
+    ETHOSU_PMU_WD_TRANS_WS_SC0 = 218
+    ETHOSU_PMU_WD_TRANS_WS_SC1 = 219
+    ETHOSU_PMU_WD_TRANS_WS_SC2 = 220
+    ETHOSU_PMU_WD_TRANS_WS_SC3 = 221
+    ETHOSU_PMU_WD_TRANS_WS_TC = 222
+
+
+@dataclass(frozen=True)
+class EthosUPmuCounter:
+    """One populated Ethos-U PMU event counter (experimental API)."""
+
+    event_type: EthosUPmuEvent
+    count: float
+    overflow: bool
+
+
+@dataclass(frozen=True)
+class EthosUPmuProfileEvent:
+    """PMU measurements for one Ethos-U invocation (experimental API)."""
+
+    product: EthosUProduct
+    platform: EthosUPlatform
+    macs_per_cycle: int
+    success: bool
+    register_base: int
+    cycle_count: float
+    cycle_overflow: bool
+    counters: tuple[EthosUPmuCounter, ...]
+
+
+def parse_pmu_profile_event(metadata: bytes) -> EthosUPmuProfileEvent:
+    """Decode one Ethos-U PMU delegate metadata blob (experimental API).
+
+    Args:
+        metadata (bytes): Raw ETDump delegate debug metadata.
+
+    Returns:
+        EthosUPmuProfileEvent: Decoded NPU cycles and PMU counters.
+
+    Raises:
+        ValueError: If the blob has an invalid format, version, or event ID.
+
+    """
+    if len(metadata) < 4:
+        raise ValueError("Ethos-U PMU metadata is shorter than its header")
+    if metadata[:3] != _MAGIC_PREFIX:
+        raise ValueError(f"Unsupported Ethos-U PMU metadata magic: {metadata[:4]!r}")
+    try:
+        version = int(metadata[3:4])
+    except ValueError as exc:
+        raise ValueError("Invalid Ethos-U PMU metadata version") from exc
+    parsers = {1: _parse_pmu_profile_event_v1}
+    parser = parsers.get(version)
+    if parser is None:
+        raise ValueError(
+            f"Unsupported Ethos-U PMU metadata version: {version}; "
+            f"supported versions: {set(parsers.keys())}"
+        )
+    else:
+        return parser(metadata)
+
+
+def _parse_pmu_profile_event_v1(metadata: bytes) -> EthosUPmuProfileEvent:
+    if len(metadata) < _HEADER.size:
+        raise ValueError("Ethos-U PMU metadata is shorter than its header")
+
+    (
+        _,
+        product,
+        macs_per_cycle,
+        platform_id,
+        flags,
+        register_base,
+        cycle_count,
+        counter_count,
+    ) = _HEADER.unpack_from(metadata)
+    try:
+        platform = EthosUPlatform(platform_id)
+    except ValueError as exc:
+        raise ValueError(f"Unknown Ethos-U platform ID: {platform_id}") from exc
+    try:
+        product_type = EthosUProduct(product)
+    except ValueError as exc:
+        raise ValueError(f"Unknown Ethos-U product ID: {product}") from exc
+    if flags & ~0b11:
+        raise ValueError(f"Unsupported Ethos-U PMU flags: {flags:#x}")
+    if counter_count > _MAX_COUNTERS:
+        raise ValueError(f"Too many Ethos-U PMU counters: {counter_count}")
+
+    expected_size = _HEADER.size + counter_count * _COUNTER.size
+    if len(metadata) != expected_size:
+        raise ValueError(
+            f"Ethos-U PMU metadata has {len(metadata)} bytes; expected {expected_size}"
+        )
+
+    counters = _parse_counters(metadata, _HEADER.size, counter_count)
+
+    return EthosUPmuProfileEvent(
+        product=product_type,
+        platform=platform,
+        macs_per_cycle=macs_per_cycle,
+        success=bool(flags & 2),
+        register_base=register_base,
+        cycle_count=float("nan") if flags & 1 else float(cycle_count),
+        cycle_overflow=bool(flags & 1),
+        counters=counters,
+    )
+
+
+def _parse_counters(
+    metadata: bytes, offset: int, counter_count: int
+) -> tuple[EthosUPmuCounter, ...]:
+    counters = []
+    for slot in range(counter_count):
+        event_id, count, overflow = _COUNTER.unpack_from(
+            metadata, offset + slot * _COUNTER.size
+        )
+        try:
+            event_type = EthosUPmuEvent(event_id)
+        except ValueError as exc:
+            raise ValueError(f"Unknown Ethos-U PMU event ID: {event_id}") from exc
+        if overflow not in (0, 1):
+            raise ValueError(f"Invalid Ethos-U PMU overflow value: {overflow}")
+        counters.append(
+            EthosUPmuCounter(
+                event_type, float("nan") if overflow else float(count), bool(overflow)
+            )
+        )
+    return tuple(counters)
+
+
+def parse_ethosu_delegate_pmu_metadata(
+    metadata_list: Sequence[bytes | bytearray | str | None],
+) -> dict[str, Any]:
+    """Decode Ethos-U PMU samples for Inspector (experimental API).
+
+    Args:
+        metadata_list (Sequence[bytes | bytearray | str | None]): Raw samples.
+
+    Returns:
+        dict[str, Any]: Decoded samples in the `ethosu_pmu` key, or an empty
+        dictionary for unrelated delegate metadata. Missing samples retain
+        their positions as None.
+
+    """
+    records: list[dict[str, Any] | None] = []
+    found = False
+    for metadata in metadata_list:
+        if not isinstance(metadata, (bytes, bytearray)) or not metadata.startswith(
+            _MAGIC_PREFIX
+        ):
+            records.append(None)
+            continue
+
+        record = parse_pmu_profile_event(bytes(metadata))
+        found = True
+        records.append(
+            {
+                "product": record.product,
+                "platform": record.platform,
+                "macs_per_cycle": record.macs_per_cycle,
+                "success": record.success,
+                "register_base": record.register_base,
+                "cycle_count": record.cycle_count,
+                "cycle_overflow": record.cycle_overflow,
+                "counters": [
+                    {
+                        "event_type": counter.event_type,
+                        "event_id": counter.event_type.value,
+                        "count": counter.count,
+                        "overflow": counter.overflow,
+                    }
+                    for counter in record.counters
+                ],
+            }
+        )
+
+    return {"ethosu_pmu": records} if found else {}
diff --git a/backends/arm/runtime/EthosUBackend_CoreDriver.cpp b/backends/arm/runtime/EthosUBackend_CoreDriver.cpp
index 5d905365329..d5e67b55b5f 100644
--- a/backends/arm/runtime/EthosUBackend_CoreDriver.cpp
+++ b/backends/arm/runtime/EthosUBackend_CoreDriver.cpp
@@ -54,6 +54,7 @@ namespace arm {
 
 struct PlatformState {};
 
+// cppcheck-suppress unusedFunction
 executorch::runtime::Error platform_init(
     executorch::runtime::ArrayRef<executorch::runtime::CompileSpec> /*specs*/,
     executorch::runtime::MemoryAllocator* /*allocator*/,
@@ -61,14 +62,18 @@ executorch::runtime::Error platform_init(
   return executorch::runtime::Error::Ok;
 }
 
+// cppcheck-suppress unusedFunction
 void platform_destroy(PlatformState* /*state*/) {}
 
+// cppcheck-suppress unusedFunction
 bool needs_scratch_allocation() {
   return true;
 }
 
+// cppcheck-suppress unusedFunction
 Error platform_execute(
-    BackendExecutionContext& /*context*/,
+    // cppcheck-suppress constParameterReference
+    [[maybe_unused]] BackendExecutionContext& context,
     [[maybe_unused]] const ExecutionHandle* execution_handle,
     const VelaHandles& handles,
     int input_count,
@@ -137,6 +142,9 @@ Error platform_execute(
   executorch::backends::arm::EthosUInvocationContext invocation_context{};
   invocation_context.delegate_handle =
       reinterpret_cast<uintptr_t>(execution_handle);
+#if defined(ET_EVENT_TRACER_ENABLED)
+  invocation_context.event_tracer = context.event_tracer();
+#endif
   int result = ethosu_invoke_v3(
       driver.get(),
       static_cast<const void*>(handles.cmd_data),
diff --git a/backends/arm/runtime/EthosUBackend_Pmu.h b/backends/arm/runtime/EthosUBackend_Pmu.h
index b80098235c6..1b026a45faa 100644
--- a/backends/arm/runtime/EthosUBackend_Pmu.h
+++ b/backends/arm/runtime/EthosUBackend_Pmu.h
@@ -8,6 +8,10 @@
 
 #include <cstdint>
 
+#if defined(ET_EVENT_TRACER_ENABLED)
+#include <executorch/runtime/core/event_tracer.h>
+#endif
+
 namespace executorch::backends::arm {
 
 // EthosUStatsBuffer is defined in EthosUExecutionStats.h.
@@ -17,6 +21,10 @@ struct EthosUInvocationContext {
   EthosUStatsBuffer* buffer = nullptr;
   uintptr_t delegate_handle = 0;
   uint32_t counter_count = 0;
+#if defined(ET_EVENT_TRACER_ENABLED)
+  executorch::runtime::EventTracer* event_tracer = nullptr;
+  executorch::runtime::EventTracerEntry cycle_event{};
+#endif
 };
 
 bool ethosu_execution_metrics_enabled() noexcept;
diff --git a/backends/arm/runtime/EthosUExecutionStats.cpp b/backends/arm/runtime/EthosUExecutionStats.cpp
index 92225bea937..7c51d1762eb 100644
--- a/backends/arm/runtime/EthosUExecutionStats.cpp
+++ b/backends/arm/runtime/EthosUExecutionStats.cpp
@@ -13,6 +13,22 @@
 #include <executorch/backends/arm/runtime/EthosUBackend_Pmu.h>
 #include <executorch/backends/arm/runtime/EthosUExecutionStats.h>
 
+#if defined(ET_EVENT_TRACER_ENABLED)
+namespace {
+void write_le32(uint8_t* destination, uint32_t value) {
+  for (size_t byte = 0; byte < 4; ++byte) {
+    destination[byte] = static_cast<uint8_t>(value >> (8 * byte));
+  }
+}
+
+void write_le64(uint8_t* destination, uint64_t value) {
+  for (size_t byte = 0; byte < 8; ++byte) {
+    destination[byte] = static_cast<uint8_t>(value >> (8 * byte));
+  }
+}
+} // namespace
+#endif
+
 namespace executorch::backends::arm {
 namespace {
 std::atomic<EthosUStatsBuffer*> capture_buffer{nullptr};
@@ -44,7 +60,11 @@ void ethosu_inference_begin(struct ethosu_driver* drv, void* user_arg) {
   invocation->counter_count = 0;
   invocation->buffer =
       executorch::backends::arm::capture_buffer.load(std::memory_order_acquire);
-  if (invocation->buffer != nullptr) {
+  if (invocation->buffer != nullptr
+#if defined(ET_EVENT_TRACER_ENABLED)
+      || invocation->event_tracer != nullptr
+#endif
+  ) {
     static constexpr ethosu_pmu_event_type kU55U65Events[] = {
         ETHOSU_PMU_AXI0_RD_DATA_BEAT_RECEIVED,
         ETHOSU_PMU_AXI1_RD_DATA_BEAT_RECEIVED,
@@ -88,6 +108,14 @@ void ethosu_inference_begin(struct ethosu_driver* drv, void* user_arg) {
       ETHOSU_PMU_CYCCNT_Reset(drv);
       ETHOSU_PMU_EVCNTR_ALL_Reset(drv);
       ETHOSU_PMU_Set_CNTR_OVS(drv, event_mask | ETHOSU_PMU_CCNT_Msk);
+#if defined(ET_EVENT_TRACER_ENABLED)
+      if (invocation->event_tracer != nullptr) {
+        invocation->cycle_event =
+            invocation->event_tracer->start_profiling_delegate(
+                executorch::backends::arm::kEthosUCycleEventName,
+                executorch::runtime::kUnsetDelegateDebugIntId);
+      }
+#endif
     }
   }
 
@@ -101,7 +129,7 @@ void ethosu_inference_end(struct ethosu_driver* drv, void* user_arg) {
     return;
   }
 
-  if (invocation->buffer != nullptr && invocation->counter_count != 0) {
+  if (invocation->counter_count != 0) {
     executorch::backends::arm::EthosUExecutionRecord record{};
     record.delegate_handle = invocation->delegate_handle;
     record.success = drv->job.result == ETHOSU_JOB_RESULT_OK;
@@ -120,7 +148,40 @@ void ethosu_inference_end(struct ethosu_driver* drv, void* user_arg) {
     }
     ETHOSU_PMU_Disable(drv);
     EthosUBackend_npu_end();
-    invocation->buffer->append(record);
+#if defined(ET_EVENT_TRACER_ENABLED)
+    if (invocation->event_tracer != nullptr) {
+      // Encode metadata in format described in EthosUExecutionStats.h
+      uint8_t metadata[executorch::backends::arm::kEthosUCycleMetadataMaxSize]{
+          'E', 'U', 'C', '1'};
+      write_le32(metadata + 4, record.stats.product);
+      write_le32(metadata + 8, 1u << drv->dev.caps.log2_macs);
+      write_le32(metadata + 12, static_cast<uint32_t>(record.stats.platform));
+      const uint32_t flags =
+          (record.stats.cycle_overflow ? 1u : 0u) | (record.success ? 2u : 0u);
+      write_le32(metadata + 16, flags);
+      write_le64(metadata + 20, record.stats.device_identifier);
+      write_le64(metadata + 28, record.stats.cycle_count);
+      write_le32(metadata + 36, record.stats.counter_count);
+      for (uint32_t slot = 0; slot < record.stats.counter_count; ++slot) {
+        const size_t offset =
+            executorch::backends::arm::kEthosUCycleMetadataHeaderSize +
+            slot * executorch::backends::arm::kEthosUCycleCounterMetadataSize;
+        const auto& counter = record.stats.counters[slot];
+        write_le32(metadata + offset, counter.event_id);
+        write_le64(metadata + offset + 4, counter.value);
+        write_le32(metadata + offset + 12, counter.overflow ? 1u : 0u);
+      }
+      const size_t metadata_size =
+          executorch::backends::arm::kEthosUCycleMetadataHeaderSize +
+          record.stats.counter_count *
+              executorch::backends::arm::kEthosUCycleCounterMetadataSize;
+      invocation->event_tracer->end_profiling_delegate(
+          invocation->cycle_event, metadata, metadata_size);
+    }
+#endif
+    if (invocation->buffer != nullptr) {
+      invocation->buffer->append(record);
+    }
     return;
   }
   EthosUBackend_npu_end();
diff --git a/backends/arm/runtime/EthosUExecutionStats.h b/backends/arm/runtime/EthosUExecutionStats.h
index fa04759f237..4e3c905255c 100644
--- a/backends/arm/runtime/EthosUExecutionStats.h
+++ b/backends/arm/runtime/EthosUExecutionStats.h
@@ -36,6 +36,20 @@ bool ethosu_execution_metrics_enabled() noexcept;
 
 constexpr size_t kMaxPmuEventCounters = 8;
 
+constexpr char kEthosUCycleEventName[] = "ethosu.pmu.counters";
+// Experimental format; layout and fields may change without compatibility.
+// ETDump delegate_debug_metadata starts with "EUC" and ASCII version '1'
+// [0:4], followed by little-endian product [4:8], MACs per cycle [8:12],
+// EthosUPlatform [12:16], flags [16:20] (bit 0: cycle overflow,
+// bit 1: invocation succeeded), register base [20:28], NPU cycle count
+// [28:36], and counter count [36:40].
+// Each populated counter then stores
+// a symbolic event ID (4 bytes), count (8 bytes), and overflow (4 bytes).
+constexpr size_t kEthosUCycleMetadataHeaderSize = 40;
+constexpr size_t kEthosUCycleCounterMetadataSize = 16;
+constexpr size_t kEthosUCycleMetadataMaxSize = kEthosUCycleMetadataHeaderSize +
+    kMaxPmuEventCounters * kEthosUCycleCounterMetadataSize;
+
 enum class EthosUPlatform : uint8_t {
   CoreDriver,
 };
diff --git a/backends/arm/runtime/targets.bzl b/backends/arm/runtime/targets.bzl
index 8ddabe90ade..75cb47c7bbc 100644
--- a/backends/arm/runtime/targets.bzl
+++ b/backends/arm/runtime/targets.bzl
@@ -25,6 +25,7 @@ def define_common_targets():
     runtime.cxx_library(
         name = "ethosu_invocation_context",
         exported_headers = ["EthosUBackend_Pmu.h"],
+        exported_deps = ["//executorch/runtime/core:event_tracer"],
         visibility = ["PUBLIC"],
     )
     runtime.cxx_library(
diff --git a/backends/arm/runtime/tests/ethos-u/CMakeLists.txt b/backends/arm/runtime/tests/ethos-u/CMakeLists.txt
index 5a2ee4240e9..dbd860a03be 100644
--- a/backends/arm/runtime/tests/ethos-u/CMakeLists.txt
+++ b/backends/arm/runtime/tests/ethos-u/CMakeLists.txt
@@ -92,6 +92,26 @@ target_include_directories(
     "${EXECUTORCH_ROOT}/.."
     "${EXECUTORCH_ROOT}/examples/arm/arm-scratch/ethos-u/core_software/core_driver/include"
 )
+target_compile_definitions(
+  ethosu_execution_stats_test_library PRIVATE ET_EVENT_TRACER_ENABLED
+)
+target_link_libraries(
+  ethosu_execution_stats_test_library PUBLIC executorch_core
+)
+
+add_library(
+  ethosu_execution_stats_no_trace_test_library STATIC
+  "${EXECUTORCH_ROOT}/backends/arm/runtime/EthosUExecutionStats.cpp"
+)
+target_include_directories(
+  ethosu_execution_stats_no_trace_test_library
+  PRIVATE
+    "${EXECUTORCH_ROOT}/.."
+    "${EXECUTORCH_ROOT}/examples/arm/arm-scratch/ethos-u/core_software/core_driver/include"
+)
+target_link_libraries(
+  ethosu_execution_stats_no_trace_test_library PUBLIC executorch_core
+)
 
 add_executable(
   ethosu_execution_stats_test
@@ -105,8 +125,8 @@ target_include_directories(
     "${EXECUTORCH_ROOT}/examples/arm/arm-scratch/ethos-u/core_software/core_driver/include"
 )
 target_link_libraries(
-  ethosu_execution_stats_test PRIVATE ethosu_execution_stats_test_library
-                                      Threads::Threads
+  ethosu_execution_stats_test
+  PRIVATE ethosu_execution_stats_no_trace_test_library Threads::Threads
 )
 add_test(NAME ethosu_execution_stats COMMAND ethosu_execution_stats_test)
 set_tests_properties(
@@ -124,6 +144,9 @@ target_include_directories(
     "${EXECUTORCH_ROOT}/.."
     "${EXECUTORCH_ROOT}/examples/arm/arm-scratch/ethos-u/core_software/core_driver/include"
 )
+target_compile_definitions(
+  ethosu_pmu_callbacks_test PRIVATE ET_EVENT_TRACER_ENABLED
+)
 target_link_libraries(
   ethosu_pmu_callbacks_test PRIVATE ethosu_execution_stats_test_library
                                     Threads::Threads
diff --git a/backends/arm/test/ethosu_pmu_callbacks_test.cpp b/backends/arm/test/ethosu_pmu_callbacks_test.cpp
index f984be616c7..8914f60ef4b 100644
--- a/backends/arm/test/ethosu_pmu_callbacks_test.cpp
+++ b/backends/arm/test/ethosu_pmu_callbacks_test.cpp
@@ -15,6 +15,7 @@
 
 #include <cstdio>
 #include <cstdlib>
+#include <cstring>
 #include <thread>
 
 #define CHECK(expr)                                                           \
@@ -26,6 +27,96 @@
   } while (false)
 
 using namespace executorch::backends::arm;
+using namespace executorch::runtime;
+
+class CapturingTracer final : public EventTracer {
+ public:
+  uint8_t metadata[kEthosUCycleMetadataMaxSize]{};
+  size_t metadata_size = 0;
+  bool started = false;
+  bool ended = false;
+
+  void create_event_block(const char*) override {}
+  EventTracerEntry start_profiling(const char*, ChainID, DebugHandle) override {
+    return {};
+  }
+  EventTracerEntry start_profiling_delegate(
+      const char* name,
+      DelegateDebugIntId index) override {
+    CHECK(std::strcmp(name, kEthosUCycleEventName) == 0);
+    CHECK(index == kUnsetDelegateDebugIntId);
+    started = true;
+    EventTracerEntry entry{};
+    entry.event_id = 17;
+    return entry;
+  }
+  void end_profiling_delegate(
+      EventTracerEntry entry,
+      const void* data,
+      size_t size) override {
+    CHECK(started);
+    CHECK(entry.event_id == 17);
+    CHECK(size <= sizeof(metadata));
+    std::memcpy(metadata, data, size);
+    metadata_size = size;
+    ended = true;
+  }
+  void log_profiling_delegate(
+      const char*,
+      DelegateDebugIntId,
+      et_timestamp_t,
+      et_timestamp_t,
+      const void*,
+      size_t) override {}
+  void end_profiling(EventTracerEntry) override {}
+  void track_allocation(AllocatorID, size_t) override {}
+  AllocatorID track_allocator(const char*) override {
+    return 0;
+  }
+  Result<bool> log_evalue(const EValue&, LoggedEValueType) override {
+    return true;
+  }
+  Result<bool> log_intermediate_output_delegate(
+      const char*,
+      DelegateDebugIntId,
+      const executorch::aten::Tensor&) override {
+    return true;
+  }
+  Result<bool> log_intermediate_output_delegate(
+      const char*,
+      DelegateDebugIntId,
+      const ArrayRef<executorch::aten::Tensor>) override {
+    return true;
+  }
+  Result<bool> log_intermediate_output_delegate(
+      const char*,
+      DelegateDebugIntId,
+      const int&) override {
+    return true;
+  }
+  Result<bool> log_intermediate_output_delegate(
+      const char*,
+      DelegateDebugIntId,
+      const bool&) override {
+    return true;
+  }
+  Result<bool> log_intermediate_output_delegate(
+      const char*,
+      DelegateDebugIntId,
+      const double&) override {
+    return true;
+  }
+  void set_delegation_intermediate_output_filter(
+      EventTracerFilterBase*) override {}
+};
+
+uint64_t read_le(const uint8_t* bytes, size_t size) {
+  uint64_t value = 0;
+  for (size_t index = 0; index < size; ++index) {
+    value |= static_cast<uint64_t>(bytes[index]) << (8 * index);
+  }
+  return value;
+}
 
 extern "C" {
 void ethosu_inference_begin(ethosu_driver*, void*);
@@ -112,5 +203,69 @@ int main() {
   CHECK(observer_ends == 3);
 
   CHECK(set_ethosu_stats_buffer(nullptr) == &buffer);
+
+  CapturingTracer tracer;
+  EthosUInvocationContext traced_invocation{};
+  traced_invocation.event_tracer = &tracer;
+  ethosu_inference_begin(&u85, &traced_invocation);
+  CHECK(pmu(&u85).enabled);
+  pmu(&u85).cycles = 123456;
+  pmu(&u85).counts[0] = 11;
+  pmu(&u85).counts[5] = 67;
+  pmu(&u85).overflow = ETHOSU_PMU_CCNT_Msk | (1u << 5);
+  ethosu_inference_end(&u85, &traced_invocation);
+  CHECK(!pmu(&u85).enabled);
+  CHECK(tracer.started && tracer.ended);
+  CHECK(
+      tracer.metadata_size ==
+      kEthosUCycleMetadataHeaderSize + 7 * kEthosUCycleCounterMetadataSize);
+  CHECK(std::memcmp(tracer.metadata, "EUC1", 4) == 0);
+  CHECK(read_le(tracer.metadata + 4, 4) == 2);
+  CHECK(read_le(tracer.metadata + 8, 4) == 256);
+  CHECK(
+      read_le(tracer.metadata + 12, 4) ==
+      static_cast<uint32_t>(EthosUPlatform::CoreDriver));
+  CHECK(read_le(tracer.metadata + 16, 4) == 1);
+  CHECK(read_le(tracer.metadata + 20, 8) == 0x50000000);
+  CHECK(read_le(tracer.metadata + 28, 8) == 123456);
+  CHECK(read_le(tracer.metadata + 36, 4) == 7);
+  for (size_t slot = 0; slot < 7; ++slot) {
+    const size_t offset =
+        kEthosUCycleMetadataHeaderSize + slot * kEthosUCycleCounterMetadataSize;
+    CHECK(read_le(tracer.metadata + offset, 4) == pmu(&u85).events[slot]);
+    CHECK(read_le(tracer.metadata + offset + 4, 8) == pmu(&u85).counts[slot]);
+    CHECK(read_le(tracer.metadata + offset + 12, 4) == (slot == 5));
+  }
+
+  CapturingTracer other_tracer;
+  EthosUInvocationContext other_invocation{};
+  other_invocation.event_tracer = &other_tracer;
+  ethosu_inference_begin(&u55, &other_invocation);
+  pmu(&u55).cycles = 45;
+  pmu(&u55).counts[3] = 9;
+  pmu(&u55).overflow = 1u << 3;
+  ethosu_inference_end(&u55, &other_invocation);
+  CHECK(other_tracer.started && other_tracer.ended);
+  CHECK(
+      other_tracer.metadata_size ==
+      kEthosUCycleMetadataHeaderSize + 4 * kEthosUCycleCounterMetadataSize);
+  CHECK(read_le(other_tracer.metadata + 8, 4) == 128);
+  CHECK(
+      read_le(other_tracer.metadata + 12, 4) ==
+      static_cast<uint32_t>(EthosUPlatform::CoreDriver));
+  CHECK(read_le(other_tracer.metadata + 16, 4) == 2);
+  CHECK(read_le(other_tracer.metadata + 20, 8) == 0x40000000);
+  CHECK(read_le(other_tracer.metadata + 28, 8) == 45);
+  CHECK(read_le(other_tracer.metadata + 36, 4) == 4);
+  for (size_t slot = 0; slot < 4; ++slot) {
+    const size_t offset =
+        kEthosUCycleMetadataHeaderSize + slot * kEthosUCycleCounterMetadataSize;
+    CHECK(read_le(other_tracer.metadata + offset, 4) == pmu(&u55).events[slot]);
+    CHECK(
+        read_le(other_tracer.metadata + offset + 4, 8) ==
+        pmu(&u55).counts[slot]);
+    CHECK(read_le(other_tracer.metadata + offset + 12, 4) == (slot == 3));
+  }
+  CHECK(buffer.size == 2);
   std::puts("Ethos-U PMU callbacks: PASS");
 }
diff --git a/backends/arm/test/misc/test_parse_ethosu_delegate_metadata.py b/backends/arm/test/misc/test_parse_ethosu_delegate_metadata.py
new file mode 100644
index 00000000000..bf03f80d5db
--- /dev/null
+++ b/backends/arm/test/misc/test_parse_ethosu_delegate_metadata.py
@@ -0,0 +1,150 @@
+# Copyright 2026 Arm Limited and/or its affiliates.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+import math
+import struct
+import unittest
+
+from executorch.backends.arm.ethosu.parse_delegate_metadata import (
+    _COUNTER,
+    _HEADER,
+    _MAGIC_PREFIX,
+    EthosUPlatform,
+    EthosUPmuEvent,
+    EthosUProduct,
+    parse_ethosu_delegate_pmu_metadata,
+    parse_pmu_profile_event,
+)
+
+
+def _metadata(
+    *counters: tuple[int, int, int],
+    flags: int = 2,
+    product: int = 2,
+    platform: int = 0,
+    macs_per_cycle: int = 256,
+) -> bytes:
+    header = _HEADER.pack(
+        _MAGIC_PREFIX + b"1",
+        product,
+        macs_per_cycle,
+        platform,
+        flags,
+        0x50000000,
+        123456,
+        len(counters),
+    )
+    return header + b"".join(_COUNTER.pack(*counter) for counter in counters)
+
+
+class TestEthosUDelegateMetadata(unittest.TestCase):
+    """Check Ethos-U PMU metadata decoding and Inspector adaptation."""
+
+    def test_decodes_product(self) -> None:
+        """Map each core-driver product ID to its enum value."""
+        for product in EthosUProduct:
+            with self.subTest(product=product):
+                self.assertIs(
+                    parse_pmu_profile_event(_metadata(product=product.value)).product,
+                    product,
+                )
+
+    def test_decodes_profile_event(self) -> None:
+        """Decode counters into their symbolic event types."""
+        metadata = _metadata((97, 67, 1), (178, 11, 0))
+
+        record = parse_pmu_profile_event(metadata)
+
+        self.assertIs(record.product, EthosUProduct.U85)
+        self.assertIs(record.platform, EthosUPlatform.CoreDriver)
+        self.assertEqual(record.macs_per_cycle, 256)
+        self.assertTrue(record.success)
+        self.assertEqual(record.register_base, 0x50000000)
+        self.assertEqual(record.cycle_count, 123456)
+        self.assertIsInstance(record.cycle_count, float)
+        self.assertFalse(record.cycle_overflow)
+        self.assertEqual(len(record.counters), 2)
+        self.assertEqual(
+            record.counters[0].event_type, EthosUPmuEvent.ETHOSU_PMU_MAC_ACTIVE
+        )
+        self.assertTrue(math.isnan(record.counters[0].count))
+        self.assertTrue(record.counters[0].overflow)
+        self.assertEqual(
+            record.counters[1].event_type, EthosUPmuEvent.ETHOSU_PMU_WD_ACTIVE
+        )
+        self.assertFalse(record.counters[1].overflow)
+        self.assertEqual(record.counters[1].count, 11)
+        self.assertIsInstance(record.counters[1].count, float)
+
+    def test_cycle_overflow_returns_nan(self) -> None:
+        """Use NaN when the cycle counter overflows."""
+        record = parse_pmu_profile_event(_metadata(flags=3))
+
+        self.assertTrue(record.cycle_overflow)
+        self.assertTrue(math.isnan(record.cycle_count))
+
+    def test_inspector_adapter_preserves_sample_positions(self) -> None:
+        """Keep sample indices when unrelated or empty entries occur."""
+        metadata = _metadata((112, 45, 0))
+
+        parsed = parse_ethosu_delegate_pmu_metadata([b"", b"other", metadata])
+
+        self.assertEqual(parsed["ethosu_pmu"][:2], [None, None])
+        sample = parsed["ethosu_pmu"][2]
+        self.assertIs(sample["product"], EthosUProduct.U85)
+        self.assertIs(sample["platform"], EthosUPlatform.CoreDriver)
+        self.assertEqual(sample["macs_per_cycle"], 256)
+        self.assertEqual(sample["cycle_count"], 123456)
+        self.assertEqual(len(sample["counters"]), 1)
+        counter = sample["counters"][0]
+        self.assertIs(counter["event_type"], EthosUPmuEvent.ETHOSU_PMU_NPU_IDLE)
+        self.assertEqual(counter["event_id"], 112)
+        self.assertEqual(counter["count"], 45)
+        self.assertFalse(counter["overflow"])
+        self.assertEqual(parse_ethosu_delegate_pmu_metadata([b"other", ""]), {})
+
+    def test_rejects_invalid_metadata(self) -> None:
+        """Reject malformed Ethos-U records and unsupported event IDs."""
+        valid = _metadata((97, 67, 1))
+        invalid = {
+            "short header": (valid[:39], "shorter than its header"),
+            "wrong magic": (b"XYZ1" + valid[4:], "magic"),
+            "unsupported version": (
+                b"EUC2" + valid[4:],
+                r"supported versions: \{1\}",
+            ),
+            "invalid version": (b"EUCx" + valid[4:], "version"),
+            "extra byte": (valid + b"\x00", "expected"),
+            "too many counters": (
+                valid[:36] + struct.pack("<I", 9) + valid[40:],
+                "Too many",
+            ),
+            "unknown event": (
+                valid[:40] + _COUNTER.pack(999, 67, 1),
+                "Unknown",
+            ),
+            "unknown product": (
+                valid[:4] + struct.pack("<I", 3) + valid[8:],
+                "Unknown Ethos-U product ID",
+            ),
+            "invalid overflow": (
+                valid[:40] + _COUNTER.pack(97, 67, 2),
+                "overflow",
+            ),
+            "unknown platform": (
+                valid[:12] + struct.pack("<I", 1) + valid[16:],
+                "Unknown Ethos-U platform ID",
+            ),
+            "unknown flags": (
+                valid[:16] + struct.pack("<I", 4) + valid[20:],
+                "flags",
+            ),
+        }
+        for name, (metadata, message) in invalid.items():
+            with self.subTest(name=name), self.assertRaisesRegex(ValueError, message):
+                parse_pmu_profile_event(metadata)
+
+        with self.assertRaisesRegex(ValueError, "version"):
+            parse_ethosu_delegate_pmu_metadata([b"EUC2" + valid[4:]])
diff --git a/backends/arm/test/targets.bzl b/backends/arm/test/targets.bzl
index a529e2d9449..76523082601 100644
--- a/backends/arm/test/targets.bzl
+++ b/backends/arm/test/targets.bzl
@@ -1,3 +1,8 @@
+# Copyright 2026 Arm Limited and/or its affiliates.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
 # load("//caffe2/test/fb:defs.bzl", "define_tests")
 load("@fbcode_macros//build_defs:python_pytest.bzl", "python_pytest")
 load("@bazel_skylib//lib:paths.bzl", "paths")
@@ -80,6 +85,7 @@ def define_arm_tests():
         "misc/test_version_xfail.py",
         "misc/test_compile_spec.py",
         "misc/test_diff_pte.py",
+        "misc/test_parse_ethosu_delegate_metadata.py",
         "misc/test_external_vela_blocks.py",
         "misc/test_vela_persistent_region.py",
         "misc/test_delegated_state_partitioning.py",
diff --git a/examples/arm/smollm2_example_ethos_u/generate_sampled.py b/examples/arm/smollm2_example_ethos_u/generate_sampled.py
index fe4311a9dec..6513258fd45 100644
--- a/examples/arm/smollm2_example_ethos_u/generate_sampled.py
+++ b/examples/arm/smollm2_example_ethos_u/generate_sampled.py
@@ -30,7 +30,9 @@
 )
 
 ETHOSU_PMU_CYCLE_PATTERN = re.compile(r"ethosu_pmu_cycle_cntr\s*:\s*(\d+)")
-ETHOSU_PMU_COUNTER_PATTERN = re.compile(r"ethosu_pmu_cntr(\d+)\s*:\s*(\d+)")
+ETHOSU_PMU_COUNTER_PATTERN = re.compile(
+    r"Ethos-U NPU 0x[0-9a-fA-F]+ PMU counter (\d+) event \d+:\s*(\d+)"
+)
 ETHOSU_DELEGATIONS_PATTERN = re.compile(r"NPU delegations:\s*(\d+)")
 ETHOSU85_EVENT_NAMES = [
     "sram_read_beats",