diff --git a/examples/all-devices-app/all-devices-common/device-factory/DeviceFactory.h b/examples/all-devices-app/all-devices-common/device-factory/DeviceFactory.h
index dd22486d8b02..0d37529b8b15 100644
--- a/examples/all-devices-app/all-devices-common/device-factory/DeviceFactory.h
+++ b/examples/all-devices-app/all-devices-common/device-factory/DeviceFactory.h
@@ -242,7 +242,7 @@ class DeviceFactory
 
     void RegisterCreator(const std::string & deviceTypeArg, DeviceCreator && creator)
     {
-        if (mDefaultDevice.empty())
+        if (mDefaultDevice.empty() && deviceTypeArg != "aggregator" && deviceTypeArg != "bridged-node")
         {
             mDefaultDevice = deviceTypeArg;
         }
@@ -254,7 +254,24 @@ class DeviceFactory
         RegisterCreator(deviceTypeArg, [c = std::move(creator)](const std::string &) { return c(); });
     }
 
-    const std::string & GetDefaultDevice() const { return mDefaultDevice; }
+    const std::string & GetDefaultDevice() const
+    {
+        static const std::string kDimmableLight = "dimmable-light";
+        if (mRegistry.find(kDimmableLight) != mRegistry.end())
+        {
+            return kDimmableLight;
+        }
+        if (!mDefaultDevice.empty())
+        {
+            return mDefaultDevice;
+        }
+        if (!mRegistry.empty())
+        {
+            return mRegistry.begin()->first;
+        }
+        static const std::string kEmptyString;
+        return kEmptyString;
+    }
 
     bool IsValidDevice(const std::string & deviceTypeArg) const { return mRegistry.find(deviceTypeArg) != mRegistry.end(); }
 
diff --git a/examples/all-devices-app/esp32/CMakeLists.txt b/examples/all-devices-app/esp32/CMakeLists.txt
index 69cf800b4423..89cac814ea75 100644
--- a/examples/all-devices-app/esp32/CMakeLists.txt
+++ b/examples/all-devices-app/esp32/CMakeLists.txt
@@ -31,9 +31,14 @@ include(${CMAKE_CURRENT_LIST_DIR}/third_party/connectedhomeip/examples/common/cm
 # - config/esp32/components: Provides the 'chip' component (GN build wrapper)
 set(EXTRA_COMPONENT_DIRS
     "${CMAKE_CURRENT_LIST_DIR}/third_party/connectedhomeip/config/esp32/components"
+    "${CMAKE_CURRENT_LIST_DIR}/third_party/connectedhomeip/examples/common"
     "${CMAKE_CURRENT_LIST_DIR}/third_party/connectedhomeip/examples/platform/esp32/led_widget"
 )
 
+if(${IDF_TARGET} STREQUAL "esp32")
+    list(APPEND EXTRA_COMPONENT_DIRS "${CMAKE_CURRENT_LIST_DIR}/third_party/connectedhomeip/examples/common/m5stack-tft/repo/components")
+endif()
+
 # Compute project (output binary) name from the device selection.
 # ALL_DEVICES_ENABLED_DEVICES and ALL_DEVICES_APP_NAME may be passed as -D flags;
 # this mirrors the three-way logic in enabled_devices.cmake / enabled_devices.gni.
diff --git a/examples/all-devices-app/esp32/main/CMakeLists.txt b/examples/all-devices-app/esp32/main/CMakeLists.txt
index 1e801fe417df..bcab1ec4e3b7 100644
--- a/examples/all-devices-app/esp32/main/CMakeLists.txt
+++ b/examples/all-devices-app/esp32/main/CMakeLists.txt
@@ -34,6 +34,14 @@ set(PRIV_INCLUDE_DIRS_LIST
                       ${ALL_DEVICES_EXTRA_INCLUDE_DIRS}
 )
 
+if (CONFIG_HAVE_DISPLAY)
+    list(APPEND PRIV_INCLUDE_DIRS_LIST
+        "${CMAKE_CURRENT_LIST_DIR}/display"
+        "${CHIP_ROOT}/examples/common/screen-framework/include"
+        "${CHIP_ROOT}/examples/common/QRCode/repo/c"
+    )
+endif()
+
 # Keep top-level src/app files explicit to avoid pulling unrelated src/app/*.cpp.
 set(APP_TOPLEVEL_EXTRA_SRCS
     "${CHIP_ROOT}/src/app/SafeAttributePersistenceProvider.cpp"
@@ -57,6 +65,12 @@ set(SRC_DIRS_LIST
     "${CHIP_ROOT}/src/app/server-cluster"
 )
 
+if (CONFIG_HAVE_DISPLAY)
+    list(APPEND SRC_DIRS_LIST
+        "${CMAKE_CURRENT_LIST_DIR}/display"
+    )
+endif()
+
 idf_component_register(PRIV_INCLUDE_DIRS ${PRIV_INCLUDE_DIRS_LIST}
                        SRC_DIRS ${SRC_DIRS_LIST})
 
diff --git a/examples/all-devices-app/esp32/main/DeviceShellCommands.cpp b/examples/all-devices-app/esp32/main/DeviceShellCommands.cpp
index 209c28367a1d..9898c66453ef 100644
--- a/examples/all-devices-app/esp32/main/DeviceShellCommands.cpp
+++ b/examples/all-devices-app/esp32/main/DeviceShellCommands.cpp
@@ -1,6 +1,6 @@
 /*
  *
- *    Copyright (c) 2025 Project CHIP Authors
+ *    Copyright (c) 2025-2026 Project CHIP Authors
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
@@ -16,11 +16,12 @@
  */
 
 #include <DeviceShellCommands.h>
+#include <cstring>
 #include <device-factory/DeviceFactory.h>
 #include <lib/shell/streamer.h>
 
 // Forward declaration of the function defined in main.cpp
-void InitServerWithDeviceType(std::string deviceType);
+void SetDeviceTypeAndRestart(const std::string & deviceType);
 
 namespace chip {
 namespace Shell {
@@ -47,7 +48,9 @@ CHIP_ERROR DeviceCommands::SetDeviceTypeHandler(int argc, char ** argv)
         const auto supportedDeviceTypes = chip::app::NoHooksDeviceFactory::GetInstance().SupportedDeviceTypes();
         streamer_printf(streamer_get(), "Usage: devtype set <device-type>\r\n");
         streamer_printf(streamer_get(), "Example: devtype set contact-sensor\r\n");
+        streamer_printf(streamer_get(), "Example: devtype set * (all bridged devices)\r\n");
         streamer_printf(streamer_get(), "Supported device types:\r\n");
+        streamer_printf(streamer_get(), "  - *\r\n");
         for (const auto & deviceType : supportedDeviceTypes)
         {
             streamer_printf(streamer_get(), "  - %s\r\n", deviceType.c_str());
@@ -57,9 +60,15 @@ CHIP_ERROR DeviceCommands::SetDeviceTypeHandler(int argc, char ** argv)
 
     const char * deviceType = argv[0];
 
-    streamer_printf(streamer_get(), "Device type set to: %s\r\n", deviceType);
+    if (strcmp(deviceType, "*") != 0 && !chip::app::NoHooksDeviceFactory::GetInstance().IsValidDevice(deviceType))
+    {
+        streamer_printf(streamer_get(), "Unknown device type: %s\r\n", deviceType);
+        return CHIP_ERROR_INVALID_ARGUMENT;
+    }
+
+    streamer_printf(streamer_get(), "Device type set to: %s. Restarting...\r\n", deviceType);
 
-    InitServerWithDeviceType(std::string(deviceType));
+    SetDeviceTypeAndRestart(std::string(deviceType));
 
     return CHIP_NO_ERROR;
 }
diff --git a/examples/all-devices-app/esp32/main/Kconfig.projbuild b/examples/all-devices-app/esp32/main/Kconfig.projbuild
index fcb15edd5cf0..8916ace437d6 100644
--- a/examples/all-devices-app/esp32/main/Kconfig.projbuild
+++ b/examples/all-devices-app/esp32/main/Kconfig.projbuild
@@ -1,5 +1,5 @@
 #
-#    Copyright (c) 2025 Project CHIP Authors
+#    Copyright (c) 2025-2026 Project CHIP Authors
 #    All rights reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License");
@@ -20,11 +20,128 @@
 
 menu "Demo"
 
+    choice
+        prompt "Device Type"
+        default DEVICE_TYPE_ESP32_DEVKITC if IDF_TARGET_ESP32
+        default DEVICE_TYPE_ESP32_C3_DEVKITM if IDF_TARGET_ESP32C3
+        default DEVICE_TYPE_ESP32_C2_DEVKITM if IDF_TARGET_ESP32C2
+        default DEVICE_TYPE_ESP32_C6_DEVKITC if IDF_TARGET_ESP32C6
+        default DEVICE_TYPE_ESP32_S31_DEVKITC if IDF_TARGET_ESP32S31
+        default DEVICE_TYPE_ESP32_H2_DEVKITM if IDF_TARGET_ESP32H2
+        default DEVICE_TYPE_ESP32_H21_DEVKITM if IDF_TARGET_ESP32H21
+        default DEVICE_TYPE_ESP32_H4_DEVKITM if IDF_TARGET_ESP32H4
+        default DEVICE_TYPE_ESP32_P4_FUNCTION_EV_BOARD if IDF_TARGET_ESP32P4
+        help
+            Specifies the type of ESP32 device.
+
+            Note that the "ESP32-DevKitC" choice is compatible with a number of clone devices
+            available from third-party manufacturers.
+
+        config DEVICE_TYPE_ESP32_DEVKITC
+            bool "ESP32-DevKitC"
+            depends on IDF_TARGET_ESP32
+        config DEVICE_TYPE_ESP32_WROVER_KIT
+            bool "ESP32-WROVER-KIT_V4.1"
+            depends on IDF_TARGET_ESP32
+        config DEVICE_TYPE_M5STACK
+            bool "M5Stack"
+            depends on IDF_TARGET_ESP32
+        config DEVICE_TYPE_ESP32_C3_DEVKITM
+            bool "ESP32C3-DevKitM"
+            depends on IDF_TARGET_ESP32C3
+        config DEVICE_TYPE_ESP32_C2_DEVKITM
+            bool "ESP32C2-DevKitM"
+            depends on IDF_TARGET_ESP32C2
+        config DEVICE_TYPE_ESP32_C6_DEVKITC
+            bool "ESP32C6-DevKitC"
+            depends on IDF_TARGET_ESP32C6
+        config DEVICE_TYPE_ESP32_S31_DEVKITC
+            bool "ESP32S31-DevKitC"
+            depends on IDF_TARGET_ESP32S31
+        config DEVICE_TYPE_ESP32_H2_DEVKITM
+            bool "ESP32H2-DevKitM"
+            depends on IDF_TARGET_ESP32H2
+        config DEVICE_TYPE_ESP32_H21_DEVKITM
+            bool "ESP32H21-DevKitM"
+            depends on IDF_TARGET_ESP32H21
+        config DEVICE_TYPE_ESP32_H4_DEVKITM
+            bool "ESP32H4-DevKitM"
+            depends on IDF_TARGET_ESP32H4
+        config DEVICE_TYPE_ESP32_P4_FUNCTION_EV_BOARD
+            bool "ESP32P4 Function EV Board"
+            depends on IDF_TARGET_ESP32P4
+    endchoice
+
+    choice
+      prompt "Rendezvous Mode"
+      default RENDEZVOUS_MODE_BLE if BT_ENABLED
+      default RENDEZVOUS_MODE_SOFTAP
+      help
+          Specifies the Rendezvous mode of the peripheral.
+
+      config RENDEZVOUS_MODE_SOFTAP
+          bool "Soft-AP"
+          select ESP_WIFI_SOFTAP_SUPPORT
+      config RENDEZVOUS_MODE_BLE
+          bool "BLE"
+          depends on BT_ENABLED
+      config RENDEZVOUS_MODE_ON_NETWORK
+          bool "On-Network"
+      config RENDEZVOUS_MODE_THREAD_MESHCOP
+          bool "Thread MeshCoP"
+          depends on CHIP_DEVICE_ENABLE_THREAD_MESHCOP
+      config RENDEZVOUS_MODE_SOFTAP_ON_NETWORK
+          bool "Soft-AP / On-Network"
+          select ESP_WIFI_SOFTAP_SUPPORT
+      config RENDEZVOUS_MODE_BLE_ON_NETWORK
+          bool "BLE / On-Network"
+    endchoice
+
+    config TFT_PREDEFINED_DISPLAY_TYPE
+        int
+        range 0 5
+        default 0 if DEVICE_TYPE_ESP32_DEVKITC || DEVICE_TYPE_ESP32_H2_DEVKITM || DEVICE_TYPE_ESP32_H21_DEVKITM || DEVICE_TYPE_ESP32_H4_DEVKITM || DEVICE_TYPE_ESP32_P4_FUNCTION_EV_BOARD
+        default 0 if DEVICE_TYPE_ESP32_C3_DEVKITM || DEVICE_TYPE_ESP32_C2_DEVKITM || DEVICE_TYPE_ESP32_C6_DEVKITC || DEVICE_TYPE_ESP32_S31_DEVKITC
+        default 3 if DEVICE_TYPE_M5STACK
+        default 4 if DEVICE_TYPE_ESP32_WROVER_KIT
+
+    config HAVE_DISPLAY
+        bool
+        default y if DEVICE_TYPE_M5STACK || DEVICE_TYPE_ESP32_WROVER_KIT
+        default n if !(DEVICE_TYPE_M5STACK || DEVICE_TYPE_ESP32_WROVER_KIT)
+
+    config RENDEZVOUS_MODE
+       int
+       range 0 63
+       default 1 if RENDEZVOUS_MODE_SOFTAP
+       default 2 if RENDEZVOUS_MODE_BLE
+       default 4 if RENDEZVOUS_MODE_ON_NETWORK
+       default 32 if RENDEZVOUS_MODE_THREAD_MESHCOP
+       default 5 if RENDEZVOUS_MODE_SOFTAP_ON_NETWORK
+       default 6 if RENDEZVOUS_MODE_BLE_ON_NETWORK
+
+    config DISPLAY_AUTO_OFF
+        bool "Automatically turn off the M5Stack's Display after a few seconds"
+        default "y"
+        depends on DEVICE_TYPE_M5STACK
+        help
+            To reduce wear and heat the M5Stack's Display is automatically switched off after a few seconds
+
+    config STATUS_LED_GPIO_NUM
+        int
+        range 0 40
+        default 2 if DEVICE_TYPE_ESP32_DEVKITC         #Use LED1 (blue LED) as status LED on DevKitC
+        default 8 if DEVICE_TYPE_ESP32_C3_DEVKITM || DEVICE_TYPE_ESP32_C2_DEVKITM || DEVICE_TYPE_ESP32_C6_DEVKITC || DEVICE_TYPE_ESP32_S31_DEVKITC || DEVICE_TYPE_ESP32_H2_DEVKITM || DEVICE_TYPE_ESP32_H21_DEVKITM || DEVICE_TYPE_ESP32_H4_DEVKITM || DEVICE_TYPE_ESP32_P4_FUNCTION_EV_BOARD
+        default 26 if DEVICE_TYPE_ESP32_WROVER_KIT
+        default 40 if DEVICE_TYPE_M5STACK
+        help
+            Each board has a status led, define its pin number.
+
     config ALL_DEVICES_ENDPOINT
         int "Device Endpoint ID"
         default 1
         range 1 254
         help
-            The endpoint ID to use for the device.
+            The endpoint ID to use for the single device mode.
 
 endmenu
diff --git a/examples/all-devices-app/esp32/main/display/Button.cpp b/examples/all-devices-app/esp32/main/display/Button.cpp
new file mode 100644
index 000000000000..1b71db7b0c87
--- /dev/null
+++ b/examples/all-devices-app/esp32/main/display/Button.cpp
@@ -0,0 +1,99 @@
+/*
+ *
+ *    Copyright (c) 2026 Project CHIP Authors
+ *    All rights reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+#include "Button.h"
+#include "Display.h"
+#include "ScreenManager.h"
+#include <esp_log.h>
+#include <platform/PlatformManager.h>
+
+#define APP_BUTTON_PRESSED 0
+#define APP_BUTTON_RELEASED 1
+
+static const char TAG[] = "Button";
+
+void IRAM_ATTR button_isr_handler(void * arg)
+{
+    auto * button = static_cast<Button *>(arg);
+    if (button != nullptr && button->mButtonTimer != nullptr)
+    {
+        xTimerStartFromISR(button->mButtonTimer, nullptr);
+    }
+}
+
+void Button::TimerCallback(TimerHandle_t xTimer)
+{
+    auto * button = static_cast<Button *>(pvTimerGetTimerID(xTimer));
+    if (button == nullptr)
+    {
+        return;
+    }
+
+    int state = gpio_get_level(button->mGPIONum);
+    if (state == APP_BUTTON_PRESSED)
+    {
+        WakeDisplay();
+        int buttonId = 40 - button->mGPIONum;
+        LogErrorOnFailure(chip::DeviceLayer::PlatformMgr().ScheduleWork(
+            [](intptr_t arg) { ScreenManager::ButtonPressed(static_cast<int>(arg)); }, static_cast<intptr_t>(buttonId)));
+    }
+}
+
+esp_err_t Button::Init()
+{
+    if (mGPIONum == GPIO_NUM_NC)
+    {
+        return ESP_FAIL;
+    }
+    return Init(mGPIONum);
+}
+
+esp_err_t Button::Init(gpio_num_t gpioNum)
+{
+    mGPIONum = gpioNum;
+
+    gpio_config_t io_conf = {};
+    io_conf.intr_type     = GPIO_INTR_NEGEDGE;
+    io_conf.pin_bit_mask  = (1ULL << gpioNum);
+    io_conf.mode          = GPIO_MODE_INPUT;
+    io_conf.pull_up_en    = GPIO_PULLUP_ENABLE;
+    io_conf.pull_down_en  = GPIO_PULLDOWN_DISABLE;
+
+    esp_err_t err = gpio_config(&io_conf);
+    if (err != ESP_OK)
+    {
+        ESP_LOGE(TAG, "gpio_config failed for pin %d: %s", gpioNum, esp_err_to_name(err));
+        return err;
+    }
+
+    mButtonTimer = xTimerCreate("BtnTmr", pdMS_TO_TICKS(50), pdFALSE, this, TimerCallback);
+    if (mButtonTimer == nullptr)
+    {
+        ESP_LOGE(TAG, "Failed to create debounce timer for button on pin %d", gpioNum);
+        return ESP_FAIL;
+    }
+
+    err = gpio_isr_handler_add(gpioNum, button_isr_handler, this);
+    if (err != ESP_OK)
+    {
+        ESP_LOGE(TAG, "gpio_isr_handler_add failed for pin %d: %s", gpioNum, esp_err_to_name(err));
+        return err;
+    }
+
+    return ESP_OK;
+}
diff --git a/examples/all-devices-app/esp32/main/display/Button.h b/examples/all-devices-app/esp32/main/display/Button.h
new file mode 100644
index 000000000000..41d748fbd485
--- /dev/null
+++ b/examples/all-devices-app/esp32/main/display/Button.h
@@ -0,0 +1,49 @@
+/*
+ *
+ *    Copyright (c) 2026 Project CHIP Authors
+ *    All rights reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+#pragma once
+
+#include "driver/gpio.h"
+#include "esp_err.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/timers.h"
+
+#define BUTTON_1_GPIO_NUM ((gpio_num_t) 39)
+#define BUTTON_2_GPIO_NUM ((gpio_num_t) 38)
+#define BUTTON_3_GPIO_NUM ((gpio_num_t) 37)
+#define BUTTON_NUMBER 3
+
+class Button
+{
+public:
+    Button() = default;
+    explicit Button(gpio_num_t gpioNum) : mGPIONum(gpioNum) {}
+
+    esp_err_t Init();
+    esp_err_t Init(gpio_num_t gpioNum);
+
+    gpio_num_t GetGPIONum() const { return mGPIONum; }
+
+    static void TimerCallback(TimerHandle_t xTimer);
+
+    friend void IRAM_ATTR button_isr_handler(void * arg);
+
+private:
+    gpio_num_t mGPIONum        = GPIO_NUM_NC;
+    TimerHandle_t mButtonTimer = nullptr;
+};
diff --git a/examples/all-devices-app/esp32/main/display/DeviceDisplay.cpp b/examples/all-devices-app/esp32/main/display/DeviceDisplay.cpp
new file mode 100644
index 000000000000..d51057416568
--- /dev/null
+++ b/examples/all-devices-app/esp32/main/display/DeviceDisplay.cpp
@@ -0,0 +1,125 @@
+/*
+ *
+ *    Copyright (c) 2026 Project CHIP Authors
+ *    All rights reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+#include "DeviceDisplay.h"
+#include "Button.h"
+#include "DeviceInfoScreen.h"
+#include "DeviceSelectionScreen.h"
+#include "Display.h"
+#include "ListScreen.h"
+#include "QRCodeScreen.h"
+#include "ScreenManager.h"
+#include <esp_log.h>
+#include <lib/support/CHIPMem.h>
+#include <setup_payload/OnboardingCodesUtil.h>
+#include <setup_payload/QRCodeSetupPayloadGenerator.h>
+
+#include <app/server/Server.h>
+#include <platform/PlatformManager.h>
+
+static const char TAG[] = "DeviceDisplay";
+
+Button gButtons[BUTTON_NUMBER] = { Button(BUTTON_1_GPIO_NUM), Button(BUTTON_2_GPIO_NUM), Button(BUTTON_3_GPIO_NUM) };
+
+void PushFactoryResetScreen()
+{
+    auto * model = chip::Platform::New<SimpleListModel>();
+    if (model == nullptr)
+    {
+        return;
+    }
+    model->Title("Factory Reset?")
+        ->Item("< Cancel", []() { ScreenManager::PopScreen(); })
+        ->Item("No", []() { ScreenManager::PopScreen(); })
+        ->Item("Yes, Reset", []() {
+            ESP_LOGI(TAG, "Factory reset requested from UI, resetting...");
+            LogErrorOnFailure(chip::DeviceLayer::PlatformMgr().ScheduleWork(
+                [](intptr_t) { chip::Server::GetInstance().ScheduleFactoryReset(); }));
+        });
+
+    auto * screen = chip::Platform::New<ListScreen>(model);
+    if (screen == nullptr)
+    {
+        chip::Platform::Delete(model);
+        return;
+    }
+    ScreenManager::PushScreen(screen);
+}
+
+void InitDeviceDisplay()
+{
+    // Create buffer for QR code that can fit max size and null terminator.
+    char qrCodeBuffer[chip::QRCodeBasicSetupPayloadGenerator::kMaxQRCodeBase38RepresentationLength + 1];
+    chip::MutableCharSpan qrCodeText(qrCodeBuffer);
+
+    CHIP_ERROR chipErr = GetQRCode(qrCodeText, chip::RendezvousInformationFlags(CONFIG_RENDEZVOUS_MODE));
+    if (chipErr != CHIP_NO_ERROR)
+    {
+        ESP_LOGE(TAG, "GetQRCode() failed: %" CHIP_ERROR_FORMAT, chipErr.Format());
+        return;
+    }
+
+    esp_err_t err = InitDisplay();
+    if (err != ESP_OK)
+    {
+        ESP_LOGE(TAG, "InitDisplay() failed: %s", esp_err_to_name(err));
+        return;
+    }
+
+    ScreenManager::Init();
+
+#if CONFIG_DEVICE_TYPE_M5STACK
+    err = gpio_install_isr_service(0);
+    if (err != ESP_OK && err != ESP_ERR_INVALID_STATE)
+    {
+        ESP_LOGE(TAG, "gpio_install_isr_service failed: %s", esp_err_to_name(err));
+    }
+    for (int i = 0; i < BUTTON_NUMBER; ++i)
+    {
+        gButtons[i].Init();
+    }
+#endif // CONFIG_DEVICE_TYPE_M5STACK
+
+    ESP_LOGI(TAG, "Initializing screen hierarchy");
+
+    auto * rootModel = chip::Platform::New<SimpleListModel>();
+    if (rootModel != nullptr)
+    {
+        rootModel->Title("All Devices")
+            ->Item("Status & Info", []() { PushStatusOrQRCodeScreen(); })
+            ->Item("Select Device", []() { PushDeviceSelectionScreen(); })
+            ->Item("Factory Reset", []() { PushFactoryResetScreen(); });
+
+        auto * rootScreen = chip::Platform::New<ListScreen>(rootModel);
+        if (rootScreen != nullptr)
+        {
+            ScreenManager::PushScreen(rootScreen);
+        }
+        else
+        {
+            chip::Platform::Delete(rootModel);
+        }
+    }
+
+    // Push QR Code screen initially so it is visible immediately on boot
+    auto * qrScreen = chip::Platform::New<QRCodeScreen>(qrCodeText.data());
+    if (qrScreen != nullptr)
+    {
+        ScreenManager::PushScreen(qrScreen);
+    }
+}
diff --git a/examples/all-devices-app/esp32/main/display/DeviceDisplay.h b/examples/all-devices-app/esp32/main/display/DeviceDisplay.h
new file mode 100644
index 000000000000..4b6cbffe1dd9
--- /dev/null
+++ b/examples/all-devices-app/esp32/main/display/DeviceDisplay.h
@@ -0,0 +1,21 @@
+/*
+ *
+ *    Copyright (c) 2026 Project CHIP Authors
+ *    All rights reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+#pragma once
+
+void InitDeviceDisplay();
diff --git a/examples/all-devices-app/esp32/main/display/DeviceInfoScreen.cpp b/examples/all-devices-app/esp32/main/display/DeviceInfoScreen.cpp
new file mode 100644
index 000000000000..f7f9e6aa039d
--- /dev/null
+++ b/examples/all-devices-app/esp32/main/display/DeviceInfoScreen.cpp
@@ -0,0 +1,130 @@
+/*
+ *
+ *    Copyright (c) 2026 Project CHIP Authors
+ *    All rights reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+#include "DeviceInfoScreen.h"
+
+#if CONFIG_HAVE_DISPLAY
+
+#include "QRCodeScreen.h"
+#include "ScreenManager.h"
+#include <app/server/Server.h>
+#include <esp_heap_caps.h>
+#include <esp_netif.h>
+#include <lib/support/CHIPMem.h>
+#include <setup_payload/OnboardingCodesUtil.h>
+#include <setup_payload/QRCodeSetupPayloadGenerator.h>
+
+const std::string & GetActiveDeviceType();
+
+namespace {
+
+void PushQRCodeScreenHelper()
+{
+    char qrCodeBuffer[chip::QRCodeBasicSetupPayloadGenerator::kMaxQRCodeBase38RepresentationLength + 1];
+    chip::MutableCharSpan qrCodeText(qrCodeBuffer);
+    CHIP_ERROR err = GetQRCode(qrCodeText, chip::RendezvousInformationFlags(CONFIG_RENDEZVOUS_MODE));
+    if (err == CHIP_NO_ERROR)
+    {
+        auto * screen = chip::Platform::New<QRCodeScreen>(qrCodeText.data());
+        if (screen != nullptr)
+        {
+            ScreenManager::PushScreen(screen);
+        }
+    }
+}
+
+} // namespace
+
+DeviceInfoListModel::DeviceInfoListModel()
+{
+    mItems.push_back({ "< Back", []() { ScreenManager::PopScreen(); } });
+
+    auto & fabricTable  = chip::Server::GetInstance().GetFabricTable();
+    uint8_t fabricCount = fabricTable.FabricCount();
+    if (fabricCount > 0)
+    {
+        mItems.push_back({ "Commissioned: Yes (" + std::to_string(fabricCount) + " fab)", nullptr });
+    }
+    else
+    {
+        mItems.push_back({ "Commissioned: No", nullptr });
+    }
+
+    esp_netif_t * netif = esp_netif_get_handle_from_ifkey("WIFI_STA_DEF");
+    esp_netif_ip_info_t ipInfo;
+    if (netif != nullptr && esp_netif_get_ip_info(netif, &ipInfo) == ESP_OK && ipInfo.ip.addr != 0)
+    {
+        char ipStr[32];
+        snprintf(ipStr, sizeof(ipStr), "IP: " IPSTR, IP2STR(&ipInfo.ip));
+        mItems.push_back({ std::string(ipStr), nullptr });
+    }
+    else
+    {
+        mItems.push_back({ "IP: Not Connected", nullptr });
+    }
+
+    mItems.push_back({ "Dev: " + GetActiveDeviceType(), nullptr });
+
+    unsigned int freeHeapKb = heap_caps_get_free_size(MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL) / 1024;
+    mItems.push_back({ "RAM: " + std::to_string(freeHeapKb) + " KB free", nullptr });
+
+    mItems.push_back({ "View QR Code", []() { PushQRCodeScreenHelper(); } });
+}
+
+std::string DeviceInfoListModel::GetItemText(int i)
+{
+    if (i >= 0 && i < static_cast<int>(mItems.size()))
+    {
+        return mItems[i].text;
+    }
+    return "";
+}
+
+void DeviceInfoListModel::ItemAction(int i)
+{
+    if (i >= 0 && i < static_cast<int>(mItems.size()) && mItems[i].action)
+    {
+        mItems[i].action();
+    }
+}
+
+void PushStatusOrQRCodeScreen()
+{
+    auto & fabricTable = chip::Server::GetInstance().GetFabricTable();
+    if (fabricTable.FabricCount() == 0)
+    {
+        PushQRCodeScreenHelper();
+    }
+    else
+    {
+        auto * model = chip::Platform::New<DeviceInfoListModel>();
+        if (model == nullptr)
+        {
+            return;
+        }
+        auto * screen = chip::Platform::New<ListScreen>(model);
+        if (screen == nullptr)
+        {
+            chip::Platform::Delete(model);
+            return;
+        }
+        ScreenManager::PushScreen(screen);
+    }
+}
+
+#endif // CONFIG_HAVE_DISPLAY
diff --git a/examples/all-devices-app/esp32/main/display/DeviceInfoScreen.h b/examples/all-devices-app/esp32/main/display/DeviceInfoScreen.h
new file mode 100644
index 000000000000..0544d4d11cb3
--- /dev/null
+++ b/examples/all-devices-app/esp32/main/display/DeviceInfoScreen.h
@@ -0,0 +1,50 @@
+/*
+ *
+ *    Copyright (c) 2026 Project CHIP Authors
+ *    All rights reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+#pragma once
+
+#include "ListScreen.h"
+#include <functional>
+#include <string>
+#include <vector>
+
+#if CONFIG_HAVE_DISPLAY
+
+class DeviceInfoListModel : public ListScreen::Model
+{
+public:
+    DeviceInfoListModel();
+    virtual ~DeviceInfoListModel() = default;
+
+    std::string GetTitle() override { return "Device Info"; }
+    int GetItemCount() override { return static_cast<int>(mItems.size()); }
+    std::string GetItemText(int i) override;
+    void ItemAction(int i) override;
+
+private:
+    struct Item
+    {
+        std::string text;
+        std::function<void()> action;
+    };
+    std::vector<Item> mItems;
+};
+
+void PushStatusOrQRCodeScreen();
+
+#endif // CONFIG_HAVE_DISPLAY
diff --git a/examples/all-devices-app/esp32/main/display/DeviceSelectionScreen.cpp b/examples/all-devices-app/esp32/main/display/DeviceSelectionScreen.cpp
new file mode 100644
index 000000000000..749286d87419
--- /dev/null
+++ b/examples/all-devices-app/esp32/main/display/DeviceSelectionScreen.cpp
@@ -0,0 +1,99 @@
+/*
+ *
+ *    Copyright (c) 2026 Project CHIP Authors
+ *    All rights reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+#include "DeviceSelectionScreen.h"
+
+#if CONFIG_HAVE_DISPLAY
+
+#include "ScreenManager.h"
+#include <device-factory/DeviceFactory.h>
+#include <lib/support/CHIPMem.h>
+
+void SetDeviceTypeAndRestart(const std::string & deviceType);
+const std::string & GetActiveDeviceType();
+
+DeviceSelectionListModel::DeviceSelectionListModel()
+{
+    mItems.push_back({ "< Back", []() { ScreenManager::PopScreen(); } });
+
+    const std::string & activeDev = GetActiveDeviceType();
+    bool isAllBridged             = (activeDev == "*" || activeDev == "aggregator");
+
+    // Put current active device first so user sees it immediately
+    if (isAllBridged)
+    {
+        mItems.push_back({ "[*] All Bridged (*)", []() { ScreenManager::PopScreen(); } });
+    }
+    else
+    {
+        std::string activeLabel = "[*] " + activeDev;
+        mItems.push_back({ activeLabel, []() { ScreenManager::PopScreen(); } });
+
+        // Include All Bridged option
+        mItems.push_back({ "    All Bridged (*)", []() { SetDeviceTypeAndRestart("*"); } });
+    }
+
+    auto & deviceFactory = chip::app::NoHooksDeviceFactory::GetInstance();
+    for (const auto & deviceType : deviceFactory.SupportedDeviceTypes())
+    {
+        if (deviceType == "aggregator" || deviceType == "bridged-node" || deviceType == activeDev)
+        {
+            continue;
+        }
+
+        std::string label = "    " + deviceType;
+        std::string dev   = deviceType;
+
+        mItems.push_back({ label, [dev]() { SetDeviceTypeAndRestart(dev); } });
+    }
+}
+
+std::string DeviceSelectionListModel::GetItemText(int i)
+{
+    if (i >= 0 && i < static_cast<int>(mItems.size()))
+    {
+        return mItems[i].text;
+    }
+    return "";
+}
+
+void DeviceSelectionListModel::ItemAction(int i)
+{
+    if (i >= 0 && i < static_cast<int>(mItems.size()) && mItems[i].action)
+    {
+        mItems[i].action();
+    }
+}
+
+void PushDeviceSelectionScreen()
+{
+    auto * model = chip::Platform::New<DeviceSelectionListModel>();
+    if (model == nullptr)
+    {
+        return;
+    }
+    auto * screen = chip::Platform::New<ListScreen>(model);
+    if (screen == nullptr)
+    {
+        chip::Platform::Delete(model);
+        return;
+    }
+    ScreenManager::PushScreen(screen);
+}
+
+#endif // CONFIG_HAVE_DISPLAY
diff --git a/examples/all-devices-app/esp32/main/display/DeviceSelectionScreen.h b/examples/all-devices-app/esp32/main/display/DeviceSelectionScreen.h
new file mode 100644
index 000000000000..8bbf06427e86
--- /dev/null
+++ b/examples/all-devices-app/esp32/main/display/DeviceSelectionScreen.h
@@ -0,0 +1,50 @@
+/*
+ *
+ *    Copyright (c) 2026 Project CHIP Authors
+ *    All rights reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+#pragma once
+
+#include "ListScreen.h"
+#include <functional>
+#include <string>
+#include <vector>
+
+#if CONFIG_HAVE_DISPLAY
+
+class DeviceSelectionListModel : public ListScreen::Model
+{
+public:
+    DeviceSelectionListModel();
+    virtual ~DeviceSelectionListModel() = default;
+
+    std::string GetTitle() override { return "Select Device"; }
+    int GetItemCount() override { return static_cast<int>(mItems.size()); }
+    std::string GetItemText(int i) override;
+    void ItemAction(int i) override;
+
+private:
+    struct Item
+    {
+        std::string text;
+        std::function<void()> action;
+    };
+    std::vector<Item> mItems;
+};
+
+void PushDeviceSelectionScreen();
+
+#endif // CONFIG_HAVE_DISPLAY
diff --git a/examples/all-devices-app/esp32/main/display/QRCodeScreen.cpp b/examples/all-devices-app/esp32/main/display/QRCodeScreen.cpp
new file mode 100644
index 000000000000..389d756e8293
--- /dev/null
+++ b/examples/all-devices-app/esp32/main/display/QRCodeScreen.cpp
@@ -0,0 +1,81 @@
+/*
+ *
+ *    Copyright (c) 2026 Project CHIP Authors
+ *    All rights reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+#include "QRCodeScreen.h"
+#include "Display.h"
+#include "ScreenManager.h"
+#include "esp_log.h"
+#include "qrcodegen.h"
+
+#include <utility>
+#include <vector>
+
+static constexpr char TAG[] = "QRCodeScreen";
+
+namespace {
+
+constexpr int kVersion    = 4;
+constexpr int kModuleSize = 4;
+constexpr int kBorderSize = 1;
+
+color_t qrCodeColor = TFT_LIGHTGREY;
+
+} // namespace
+
+QRCodeScreen::QRCodeScreen(std::string text, std::string title) : title(std::move(title))
+{
+    constexpr int qrCodeSize = qrcodegen_BUFFER_LEN_FOR_VERSION(kVersion);
+
+    std::vector<uint8_t> temp(qrCodeSize);
+    qrCode.resize(qrCodeSize);
+
+    if (!qrcodegen_encodeText(text.c_str(), temp.data(), qrCode.data(), qrcodegen_Ecc_LOW, kVersion, kVersion, qrcodegen_Mask_AUTO,
+                              true))
+    {
+        ESP_LOGE(TAG, "qrcodegen_encodeText() failed");
+        qrCode.clear();
+    }
+}
+
+void QRCodeScreen::Display()
+{
+    if (qrCode.empty())
+    {
+        return;
+    }
+
+    const uint8_t * data  = qrCode.data();
+    const int size        = qrcodegen_getSize(data);
+    const int displaySize = (2 * kBorderSize + size) * kModuleSize;
+    const int displayX    = (DisplayWidth - displaySize) / 2;
+    const int displayY    = ScreenTitleSafeTop + ((DisplayHeight - ScreenTitleSafeTop - ScreenTitleSafeBottom) - displaySize) / 2;
+
+    TFT_fillRect(displayX, displayY, displaySize, displaySize, qrCodeColor);
+
+    for (int y = 0; y < size; ++y)
+    {
+        for (int x = 0; x < size; ++x)
+        {
+            if (qrcodegen_getModule(data, x, y))
+            {
+                TFT_fillRect(displayX + (kBorderSize + x) * kModuleSize, displayY + (kBorderSize + y) * kModuleSize, kModuleSize,
+                             kModuleSize, TFT_BLACK);
+            }
+        }
+    }
+}
diff --git a/examples/all-devices-app/esp32/main/display/QRCodeScreen.h b/examples/all-devices-app/esp32/main/display/QRCodeScreen.h
new file mode 100644
index 000000000000..c2d6534fae51
--- /dev/null
+++ b/examples/all-devices-app/esp32/main/display/QRCodeScreen.h
@@ -0,0 +1,37 @@
+/*
+ *
+ *    Copyright (c) 2026 Project CHIP Authors
+ *    All rights reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+#pragma once
+
+#include "Screen.h"
+#include <string>
+#include <vector>
+
+class QRCodeScreen : public Screen
+{
+public:
+    explicit QRCodeScreen(std::string text, std::string title = "QR Code");
+
+    std::string GetTitle() override { return title; }
+
+    void Display() override;
+
+private:
+    std::string title;
+    std::vector<uint8_t> qrCode;
+};
diff --git a/examples/all-devices-app/esp32/main/main.cpp b/examples/all-devices-app/esp32/main/main.cpp
index 23c9d6ee3a26..4b4004e4ef4f 100644
--- a/examples/all-devices-app/esp32/main/main.cpp
+++ b/examples/all-devices-app/esp32/main/main.cpp
@@ -1,6 +1,6 @@
 /*
  *
- *    Copyright (c) 2025 Project CHIP Authors
+ *    Copyright (c) 2025-2026 Project CHIP Authors
  *    All rights reserved.
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
@@ -28,6 +28,7 @@
 #include <credentials/examples/DeviceAttestationCredsExample.h>
 #include <device-factory/DeviceFactory.h>
 #include <device/api/allocator/ConsecutiveEndpointIdAllocator.h>
+#include <device/api/allocator/DynamicEndpointIdAllocator.h>
 #include <device/capabilities/identify/LoggingIdentifyDelegate.h>
 #include <device/types/root-node/WifiRootNode.h>
 #include <esp_heap_caps.h>
@@ -36,6 +37,7 @@
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 #include <nvs_flash.h>
+#include <oob-accessors/OOBAccessorRegistry.h>
 #include <platform/DiagnosticDataProvider.h>
 #include <platform/ESP32/ESP32Config.h>
 #include <platform/ESP32/ESP32Utils.h>
@@ -45,8 +47,16 @@
 
 #include <app_config/enabled_devices.h>
 
+#include <cctype>
 #include <memory>
 #include <string>
+#include <vector>
+
+#if CONFIG_HAVE_DISPLAY
+#include "DeviceDisplay.h"
+#include "Display.h"
+#include "ScreenManager.h"
+#endif // CONFIG_HAVE_DISPLAY
 
 #if CONFIG_ENABLE_CHIP_SHELL
 #include <DeviceShellCommands.h>
@@ -89,6 +99,26 @@ static const size_t kMaxDeviceTypeLength = 64;
 
 namespace {
 
+std::string KebabCaseToTitleCase(const std::string & input)
+{
+    std::string output  = input;
+    bool capitalizeNext = true;
+    for (char & c : output)
+    {
+        if (c == '-')
+        {
+            c              = ' ';
+            capitalizeNext = true;
+        }
+        else if (capitalizeNext)
+        {
+            c              = static_cast<char>(std::toupper(static_cast<unsigned char>(c)));
+            capitalizeNext = false;
+        }
+    }
+    return output;
+}
+
 // Use the singleton - platform event handlers report to GetInstance()
 DeviceLayer::NetworkCommissioning::ESPWiFiDriver & sWiFiDriver = DeviceLayer::NetworkCommissioning::ESPWiFiDriver::GetInstance();
 
@@ -108,7 +138,8 @@ Credentials::GroupDataProviderImpl gGroupDataProvider;
 LoggingIdentifyDelegate gIdentifyDelegate;
 chip::app::CodeDrivenDataModelProvider * gDataModelProvider = nullptr;
 std::unique_ptr<DeviceInterface> gRootNode;
-std::unique_ptr<DeviceInterface> gConstructedDevice;
+std::vector<std::unique_ptr<DeviceInterface>> gConstructedDevices;
+std::vector<std::unique_ptr<OOBAccessor>> gConstructedAccessors;
 DefaultTimerDelegate gTimerDelegate;
 
 void DeInitBLEIfCommissioned()
@@ -265,31 +296,169 @@ chip::app::DataModel::Provider * PopulateCodeDrivenDataModelProvider(PersistentS
     }
 
     auto & deviceFactory = NoHooksDeviceFactory::GetInstance();
+    gConstructedDevices.clear();
 
-    // figure out the default
-    if (gDeviceType.empty() || !deviceFactory.IsValidDevice(gDeviceType))
-    {
-        gDeviceType = deviceFactory.GetDefaultDevice();
-    }
-    auto created       = deviceFactory.Create(gDeviceType);
-    gConstructedDevice = std::move(created.device);
+    DynamicEndpointIdAllocator endpointIdAllocator;
+    constexpr size_t kMinFreeInternalHeap = 24 * 1024;
 
-    if (gConstructedDevice == nullptr)
+    if (gDeviceType == "*" || gDeviceType == "aggregator")
     {
-        ESP_LOGE(TAG, "Failed to create device of type: %s", gDeviceType.c_str());
-        return nullptr;
-    }
-
-    ConsecutiveEndpointIdAllocator allocator(CONFIG_ALL_DEVICES_ENDPOINT);
-    err = gConstructedDevice->Register(allocator, dataModelProvider);
-    if (err != CHIP_NO_ERROR)
-    {
-        ESP_LOGE(TAG, "Failed to register device: %" CHIP_ERROR_FORMAT, err.Format());
-        return nullptr;
+        if (deviceFactory.IsValidDevice("aggregator"))
+        {
+            auto aggregator = deviceFactory.Create("aggregator");
+            if (aggregator.device == nullptr)
+            {
+                ESP_LOGE(TAG, "Failed to create aggregator");
+                return nullptr;
+            }
+            EndpointId aggregatorEp = endpointIdAllocator.Allocate();
+            endpointIdAllocator.ForceNext(aggregatorEp);
+            ESP_LOGI(TAG, "Registering aggregator on endpoint %u", aggregatorEp);
+            err = aggregator.device->Register(endpointIdAllocator, dataModelProvider,
+                                              EndpointComposition::WithParent(kInvalidEndpointId));
+            if (err != CHIP_NO_ERROR)
+            {
+                ESP_LOGE(TAG, "Failed to register aggregator on endpoint %u: %" CHIP_ERROR_FORMAT, aggregatorEp, err.Format());
+                return nullptr;
+            }
+            if (aggregator.onDeviceRegistered)
+            {
+                aggregator.onDeviceRegistered();
+            }
+            gConstructedDevices.push_back(std::move(aggregator.device));
+
+            unsigned int createdCount = 0;
+            unsigned int skippedCount = 0;
+
+            for (const auto & deviceType : deviceFactory.SupportedDeviceTypes())
+            {
+                if (deviceType == "aggregator" || deviceType == "bridged-node")
+                {
+                    continue;
+                }
+
+                size_t freeInternalHeap = heap_caps_get_free_size(MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL);
+                if (freeInternalHeap < kMinFreeInternalHeap)
+                {
+                    ESP_LOGW(TAG, "Not creating '%s': low internal heap (%u bytes free, threshold %u bytes)", deviceType.c_str(),
+                             static_cast<unsigned int>(freeInternalHeap), static_cast<unsigned int>(kMinFreeInternalHeap));
+                    skippedCount++;
+                    continue;
+                }
+
+                auto bridgedNode = deviceFactory.Create("bridged-node", KebabCaseToTitleCase(deviceType));
+                if (bridgedNode.device == nullptr)
+                {
+                    ESP_LOGE(TAG, "Failed to create bridged-node for '%s'", deviceType.c_str());
+                    skippedCount++;
+                    continue;
+                }
+                EndpointId bnEp = endpointIdAllocator.Allocate();
+                endpointIdAllocator.ForceNext(bnEp);
+                ESP_LOGI(TAG, "Registering bridged-node for '%s' on endpoint %u (parent %u)", deviceType.c_str(), bnEp,
+                         aggregatorEp);
+                err = bridgedNode.device->Register(endpointIdAllocator, dataModelProvider,
+                                                   EndpointComposition::WithParent(aggregatorEp));
+                if (err != CHIP_NO_ERROR)
+                {
+                    ESP_LOGE(TAG, "Failed to register bridged-node for '%s' on endpoint %u: %" CHIP_ERROR_FORMAT,
+                             deviceType.c_str(), bnEp, err.Format());
+                    skippedCount++;
+                    continue;
+                }
+
+                auto device = deviceFactory.Create(deviceType);
+                if (device.device == nullptr)
+                {
+                    ESP_LOGE(TAG, "Failed to create device '%s'", deviceType.c_str());
+                    bridgedNode.device->Unregister(dataModelProvider);
+                    skippedCount++;
+                    continue;
+                }
+                ESP_LOGI(TAG, "Registering device '%s' with parent %u", deviceType.c_str(), bnEp);
+                err = device.device->Register(endpointIdAllocator, dataModelProvider, EndpointComposition::WithParent(bnEp));
+                if (err != CHIP_NO_ERROR)
+                {
+                    ESP_LOGE(TAG, "Failed to register device '%s' with parent %u: %" CHIP_ERROR_FORMAT, deviceType.c_str(), bnEp,
+                             err.Format());
+                    bridgedNode.device->Unregister(dataModelProvider);
+                    skippedCount++;
+                    continue;
+                }
+
+                if (bridgedNode.onDeviceRegistered)
+                {
+                    bridgedNode.onDeviceRegistered();
+                }
+                if (device.onDeviceRegistered)
+                {
+                    device.onDeviceRegistered();
+                }
+
+                gConstructedDevices.push_back(std::move(bridgedNode.device));
+                gConstructedDevices.push_back(std::move(device.device));
+                createdCount++;
+            }
+            ESP_LOGI(TAG,
+                     "Aggregator initialization complete: %u bridged devices created, %u devices skipped (remaining internal heap: "
+                     "%u bytes)",
+                     createdCount, skippedCount,
+                     static_cast<unsigned int>(heap_caps_get_free_size(MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL)));
+        }
+        else
+        {
+            auto defaultDevName = deviceFactory.GetDefaultDevice();
+            gDeviceType         = defaultDevName;
+            auto defaultDevice  = deviceFactory.Create(defaultDevName);
+            if (defaultDevice.device == nullptr)
+            {
+                ESP_LOGE(TAG, "Failed to create default device %s", defaultDevName.c_str());
+                return nullptr;
+            }
+            endpointIdAllocator.ForceNext(CONFIG_ALL_DEVICES_ENDPOINT);
+            ESP_LOGI(TAG, "Registering default device '%s' on endpoint %u", defaultDevName.c_str(),
+                     static_cast<unsigned int>(CONFIG_ALL_DEVICES_ENDPOINT));
+            err = defaultDevice.device->Register(endpointIdAllocator, dataModelProvider);
+            if (err != CHIP_NO_ERROR)
+            {
+                ESP_LOGE(TAG, "Failed to register default device '%s': %" CHIP_ERROR_FORMAT, defaultDevName.c_str(), err.Format());
+                return nullptr;
+            }
+            if (defaultDevice.onDeviceRegistered)
+            {
+                defaultDevice.onDeviceRegistered();
+            }
+            gConstructedDevices.push_back(std::move(defaultDevice.device));
+        }
     }
-    if (created.onDeviceRegistered)
+    else
     {
-        created.onDeviceRegistered();
+        if (gDeviceType.empty() || !deviceFactory.IsValidDevice(gDeviceType))
+        {
+            gDeviceType = deviceFactory.GetDefaultDevice();
+        }
+        auto device = deviceFactory.Create(gDeviceType);
+        if (device.device == nullptr)
+        {
+            ESP_LOGE(TAG, "Failed to create device of type: %s", gDeviceType.c_str());
+            return nullptr;
+        }
+
+        endpointIdAllocator.ForceNext(CONFIG_ALL_DEVICES_ENDPOINT);
+        ESP_LOGI(TAG, "Registering device '%s' on endpoint %u", gDeviceType.c_str(),
+                 static_cast<unsigned int>(CONFIG_ALL_DEVICES_ENDPOINT));
+        err = device.device->Register(endpointIdAllocator, dataModelProvider);
+        if (err != CHIP_NO_ERROR)
+        {
+            ESP_LOGE(TAG, "Failed to register device '%s': %" CHIP_ERROR_FORMAT, gDeviceType.c_str(), err.Format());
+            return nullptr;
+        }
+        if (device.onDeviceRegistered)
+        {
+            device.onDeviceRegistered();
+        }
+
+        gConstructedDevices.push_back(std::move(device.device));
     }
 
     return &dataModelProvider;
@@ -388,6 +557,32 @@ void InitServerWithDeviceType(std::string deviceType)
     SuccessOrDie(PlatformMgr().ScheduleWork(InitServer, reinterpret_cast<intptr_t>(nullptr)));
 }
 
+const std::string & GetActiveDeviceType()
+{
+    return gDeviceType;
+}
+
+void SetDeviceTypeAndRestart(const std::string & deviceType)
+{
+    ESP_LOGI(TAG, "Saving device type '%s' to NVS and restarting...", deviceType.c_str());
+    CHIP_ERROR err = ESP32Config::WriteConfigValueStr(kConfigKey_DeviceType, deviceType.c_str());
+    if (err != CHIP_NO_ERROR)
+    {
+        ESP_LOGE(TAG, "Failed to save device type to NVS: %" CHIP_ERROR_FORMAT, err.Format());
+        return;
+    }
+
+#if CONFIG_HAVE_DISPLAY
+    TFT_fillScreen(TFT_BLACK);
+    TFT_setFont(DEJAVU24_FONT, nullptr);
+    tft_fg = ScreenNormalColor;
+    TFT_print("Restarting...", 40, DisplayHeight / 2 - 20);
+#endif
+
+    vTaskDelay(pdMS_TO_TICKS(300));
+    esp_restart();
+}
+
 extern "C" void app_main()
 {
     // Initialize the ESP NVS layer.
@@ -445,6 +640,13 @@ extern "C" void app_main()
     SetDeviceAttestationCredentialsProvider(Examples::GetExampleDACProvider());
 #endif // CONFIG_ENABLE_ESP32_FACTORY_DATA_PROVIDER
 
+    // Print onboarding codes (QR code URL and manual code)
+    PrintOnboardingCodes(chip::RendezvousInformationFlags(CONFIG_RENDEZVOUS_MODE));
+
+#if CONFIG_HAVE_DISPLAY
+    InitDeviceDisplay();
+#endif // CONFIG_HAVE_DISPLAY
+
     error = PlatformMgr().StartEventLoopTask();
     if (error != CHIP_NO_ERROR)
     {
@@ -474,8 +676,9 @@ extern "C" void app_main()
     else
     {
         ESP_LOGI(TAG, "==================================================");
-        ESP_LOGI(TAG, "No stored device type found.");
-        ESP_LOGI(TAG, "Use command: devtype set <device-type>");
+        ESP_LOGI(TAG, "No stored device type found, defaulting to all bridged devices (*)");
+        ESP_LOGI(TAG, "Auto-initializing...");
         ESP_LOGI(TAG, "==================================================");
+        InitServerWithDeviceType("*");
     }
 }
diff --git a/examples/all-devices-app/esp32/sdkconfig_m5stack.defaults b/examples/all-devices-app/esp32/sdkconfig_m5stack.defaults
new file mode 100644
index 000000000000..3a3ae51ea6fc
--- /dev/null
+++ b/examples/all-devices-app/esp32/sdkconfig_m5stack.defaults
@@ -0,0 +1,102 @@
+#
+#    Copyright (c) 2026 Project CHIP Authors
+#    All rights reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+#    Description:
+#      CI and local builds use this to select the ESP32 M5Stack for all-devices-app.
+#
+CONFIG_IDF_TARGET="esp32"
+CONFIG_IDF_TARGET_ESP32=y
+CONFIG_DEVICE_TYPE_M5STACK=y
+
+# Default to 921600 baud when flashing and monitoring device
+CONFIG_ESPTOOLPY_BAUD_921600B=y
+CONFIG_ESPTOOLPY_BAUD=921600
+CONFIG_ESPTOOLPY_COMPRESSED=y
+CONFIG_ESPTOOLPY_MONITOR_BAUD_115200B=y
+CONFIG_ESPTOOLPY_MONITOR_BAUD=115200
+
+# Enable BT
+CONFIG_BT_ENABLED=y
+CONFIG_BT_NIMBLE_ENABLED=y
+
+# Disable BT connection reattempt
+CONFIG_BT_NIMBLE_ENABLE_CONN_REATTEMPT=n
+
+# Enable lwip ipv6 autoconfig
+CONFIG_LWIP_IPV6_AUTOCONFIG=y
+
+# Use a custom partition table
+CONFIG_PARTITION_TABLE_CUSTOM=y
+CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv"
+CONFIG_PARTITION_TABLE_FILENAME="partitions.csv"
+
+# Vendor and product id
+CONFIG_DEVICE_VENDOR_ID=0xFFF1
+CONFIG_DEVICE_PRODUCT_ID=0x8001
+
+# Main task needs more stack (5k)
+CONFIG_ESP_MAIN_TASK_STACK_SIZE=5120
+
+# Enable debug shell
+CONFIG_ENABLE_CHIP_SHELL=y
+
+# Enable lwIP route hooks
+CONFIG_LWIP_HOOK_IP6_ROUTE_DEFAULT=y
+CONFIG_LWIP_HOOK_ND6_GET_GW_DEFAULT=y
+
+# Serial Flasher config
+CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y
+CONFIG_ESPTOOLPY_FLASHSIZE="4MB"
+
+# Disable softap support by default
+CONFIG_ESP_WIFI_SOFTAP_SUPPORT=n
+
+# Disable Bluetooth modem sleep
+CONFIG_BTDM_CTRL_MODEM_SLEEP=n
+CONFIG_BTDM_CTRL_MODEM_SLEEP_MODE_ORIG=n
+CONFIG_BTDM_CTRL_LPCLK_SEL_MAIN_XTAL=n
+
+# Enable HKDF in mbedtls
+CONFIG_MBEDTLS_HKDF_C=y
+
+# Move functions from IRAM to flash
+CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH=y
+
+# Increase LwIP IPv6 address number
+CONFIG_LWIP_IPV6_NUM_ADDRESSES=6
+
+# Disable Read Client (saves memory)
+CONFIG_DISABLE_READ_CLIENT=y
+
+# Reduce event logging buffer DRAM usage
+CONFIG_EVENT_LOGGING_CRIT_BUFFER_SIZE=512
+CONFIG_EVENT_LOGGING_INFO_BUFFER_SIZE=512
+CONFIG_EVENT_LOGGING_DEBUG_BUFFER_SIZE=512
+
+# Optimize Flash
+CONFIG_NEWLIB_NANO_FORMAT=y
+
+# Proximity Ranging support for BLE post-commissioning
+CONFIG_USE_BLE_ONLY_FOR_COMMISSIONING=n
+
+# Enable SPIRAM / PSRAM support
+CONFIG_SPIRAM=y
+CONFIG_SPIRAM_BOOT_INIT=y
+CONFIG_SPIRAM_USE_MALLOC=y
+CONFIG_SPIRAM_TYPE_AUTO=y
+CONFIG_SPIRAM_ALLOW_STACK_EXTERNAL_MEMORY=y
+CONFIG_SPIRAM_MALLOC_ALWAYSINTERNAL=0
+CONFIG_SPIRAM_TRY_ALLOCATE_WIFI_LWIP=y
diff --git a/scripts/build/builders/esp32.py b/scripts/build/builders/esp32.py
index e3004b6b6e83..a5e6b41d004c 100644
--- a/scripts/build/builders/esp32.py
+++ b/scripts/build/builders/esp32.py
@@ -141,10 +141,8 @@ def DefaultsFileName(board: Esp32Board, app: Esp32App, enable_rpcs: bool):
                         Esp32App.TEMPERATURE_MEASUREMENT}
     if app == Esp32App.TESTS:
         return 'sdkconfig_qemu.defaults'
-    if app not in rpc_enabled_apps:
-        return 'sdkconfig.defaults'
 
-    rpc = "_rpc" if enable_rpcs else ""
+    rpc = "_rpc" if enable_rpcs and (app in rpc_enabled_apps) else ""
     if board == Esp32Board.DevKitC or board == Esp32Board.C3DevKit or board == Esp32Board.P4FunctionEV:
         return f'sdkconfig{rpc}.defaults'
     if board == Esp32Board.M5Stack:
@@ -153,6 +151,7 @@ def DefaultsFileName(board: Esp32Board, app: Esp32App, enable_rpcs: bool):
         specific_apps = {
             Esp32App.ALL_CLUSTERS,
             Esp32App.ALL_CLUSTERS_MINIMAL,
+            Esp32App.ALL_DEVICES,
             Esp32App.LIGHT,
             Esp32App.OTA_REQUESTOR,
         }