diff --git a/src/runtime_src/core/common/CMakeLists.txt b/src/runtime_src/core/common/CMakeLists.txt
index 7a99f639d03..e9e899fb88d 100644
--- a/src/runtime_src/core/common/CMakeLists.txt
+++ b/src/runtime_src/core/common/CMakeLists.txt
@@ -43,6 +43,7 @@ add_library(core_common_library_objects OBJECT
   sysinfo.cpp
   xclbin_parser.cpp
   xclbin_swemu.cpp
+  smi.cpp
   )
 
 target_include_directories(core_common_library_objects
diff --git a/src/runtime_src/core/common/smi.cpp b/src/runtime_src/core/common/smi.cpp
new file mode 100644
index 00000000000..0640c959b14
--- /dev/null
+++ b/src/runtime_src/core/common/smi.cpp
@@ -0,0 +1,242 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (C) 2025 Advanced Micro Devices, Inc. All rights reserved.
+
+#define XRT_CORE_COMMON_SOURCE
+
+// Local - Include Files
+#include "smi.h"
+
+// 3rd Party Library - Include Files
+#include <boost/property_tree/json_parser.hpp>
+#include <boost/property_tree/ptree.hpp>
+
+#include <string>
+#include <vector>
+
+namespace xrt_core::smi {
+
+using boost::property_tree::ptree;
+
+ptree 
+option::
+to_ptree() const 
+{
+  boost::property_tree::ptree pt;
+  pt.put("name", name);
+  pt.put("description", description);
+  pt.put("type", type);
+  pt.put("alias", alias);
+  pt.put("default_value", default_value);
+  pt.put("value_type", value_type);
+  if (!description_array.empty()) {
+    boost::property_tree::ptree description_array_ptree;
+    for (const auto& desc : description_array) {
+      boost::property_tree::ptree desc_node;
+      desc_node.put("name", desc.name);
+      desc_node.put("description", desc.description);
+      desc_node.put("type", desc.type);
+      description_array_ptree.push_back(std::make_pair("", desc_node));
+    }
+    pt.add_child("description_array", description_array_ptree);
+  }
+  return pt;
+}
+
+const tuple_vector& 
+smi_base::
+get_validate_test_desc() const 
+{
+  static const tuple_vector validate_test_desc = {
+    {"aie-reconfig-overhead", "Run end-to-end array reconfiguration overhead through shim DMA", "hidden"},
+    {"all", "All applicable validate tests will be executed (default)", "common"},
+    {"cmd-chain-latency", "Run end-to-end latency test using command chaining", "common"},
+    {"cmd-chain-throughput", "Run end-to-end throughput test using command chaining", "common"},
+    {"df-bw", "Run bandwidth test on data fabric", "common"},
+    {"gemm", "Measure the TOPS value of GEMM operations", "common"},
+    {"latency", "Run end-to-end latency test", "common"},
+    {"quick", "Run a subset of four tests: \n1. latency \n2. throughput \n3. cmd-chain-latency \n4. cmd-chain-throughput", "common"},
+    {"spatial-sharing-overhead", "Run Spatial Sharing Overhead Test", "hidden"},
+    {"tct-all-col", "Measure average TCT processing time for all columns", "common"},
+    {"tct-one-col", "Measure average TCT processing time for one column", "common"},
+    {"temporal-sharing-overhead", "Run Temporal Sharing Overhead Test", "hidden"},
+    {"throughput", "Run end-to-end throughput test", "common"},
+    {"aux-connection", "Check if auxiliary power is connected", "common"},
+    {"dma", "Run dma test", "common"},
+    {"thostmem-bw", "Run 'bandwidth kernel' when host memory is enabled", "common"},
+    {"m2m", "Run M2M test", "common"},
+    {"mem-bw", "Run 'bandwidth kernel' and check the throughput", "common"},
+    {"p2p", "Run P2P test", "common"},
+    {"pcie-link", "Check if PCIE link is active", "common"},
+    {"sc-version","Check if SC firmware is up-to-date", "common"},
+    {"verify", "Run 'Hello World' kernel test", "common"}
+  };
+  return validate_test_desc;
+}
+
+const tuple_vector& 
+smi_base::
+get_examine_report_desc() const 
+{
+  static const tuple_vector examine_report_desc = {
+    {"aie-partitions", "AIE partition information", "common"},
+    {"host", "Host information", "common"},
+    {"platform", "Platforms flashed on the device", "common"},
+    {"telemetry", "Telemetry data for the device", "common"},
+    {"aie", "AIE metadata in xclbin", "common"},
+    {"aiemem", "AIE memory tile information", "common"},
+    {"aieshim", "AIE shim tile status", "common"},
+    {"debug-ip-status", "Status of Debug IPs present in xclbin loaded on device", "common"},
+    {"dynamic-regions", "Information about the xclbin and the compute units", "common"},
+    {"electrical", "Electrical and power sensors present on the device", "common"},
+    {"error", "Asyncronus Error present on the device", "common"},
+    {"firewall", "Firewall status", "common"},
+    {"mailbox", "Mailbox metrics of the device", "common"},
+    {"mechanical", "Mechanical sensors on and surrounding the device", "common"},
+    {"memory", "Memory information present on the device", "common"},
+    {"pcie-info", "Pcie information of the device", "common"},
+    {"qspi-status", "QSPI write protection status", "common"},
+    {"thermal", "Thermal sensors present on the device", "common"}
+  };
+  return examine_report_desc;
+}
+
+std::vector<basic_option> 
+smi_base::
+construct_run_option_description() const 
+{
+  std::vector<basic_option> run_option_descriptions;
+  for (const auto& [name, description, type] : get_validate_test_desc()) {
+    run_option_descriptions.push_back({name, description, type});
+  }
+  return run_option_descriptions;
+}
+
+std::vector<basic_option> 
+smi_base::
+construct_report_option_description() const 
+{
+  std::vector<basic_option> report_option_descriptions;
+  for (const auto& [name, description, type] : get_examine_report_desc()) {
+    report_option_descriptions.push_back({name, description, type});
+  }
+  return report_option_descriptions;
+}
+
+ptree 
+smi_base::
+construct_validate_subcommand() const 
+{
+  ptree subcommand;
+  subcommand.put("name", "validate");
+  subcommand.put("description", "Validates the given device by executing the platform's validate executable.");
+  subcommand.put("type", "common");
+
+  std::vector<option> options = {
+    {"device", "d", "The Bus:Device.Function (e.g., 0000:d8:00.0) device of interest", "common", "", "string"},
+    {"format", "f", "Report output format. Valid values are:\n"
+                    "\tJSON        - Latest JSON schema\n"
+                    "\tJSON-2020.2 - JSON 2020.2 schema", "common", "JSON", "string"},
+    {"output", "o", "Direct the output to the given file", "common", "", "string"},
+    {"help", "h", "Help to use this sub-command", "common", "", "none"},
+    {"run", "r", "Run a subset of the test suite. Valid options are:\n",  "common", "",  "array", construct_run_option_description()},
+    {"path", "p", "Path to the directory containing validate xclbins", "hidden", "", "string"},
+    {"param", "", "Extended parameter for a given test. Format: <test-name>:<key>:<value>", "hidden", "", "string"},
+    {"pmode", "", "Specify which power mode to run the benchmarks in. Note: Some tests might be unavailable for some modes", "hidden", "", "string"}
+  };
+
+  ptree options_ptree;
+  for (const auto& option : options) {
+    options_ptree.push_back(std::make_pair("", option.to_ptree()));
+  }
+
+  subcommand.add_child("options", options_ptree);
+  return subcommand;
+}
+
+ptree 
+smi_base::
+construct_examine_subcommand() const 
+{
+  ptree subcommand;
+  subcommand.put("name", "examine");
+  subcommand.put("type", "common");
+  subcommand.put("description", "This command will 'examine' the state of the system/device and will generate a report of interest in a text or JSON format.");
+
+  std::vector<option> options = {
+    {"device", "d", "The Bus:Device.Function (e.g., 0000:d8:00.0) device of interest", "common", "", "string"},
+    {"format", "f", "Report output format. Valid values are:\n"
+                    "\tJSON        - Latest JSON schema\n"
+                    "\tJSON-2020.2 - JSON 2020.2 schema", "common", "", "string"},
+    {"output", "o", "Direct the output to the given file", "common", "", "string"},
+    {"help", "h", "Help to use this sub-command", "common", "", "none"},
+    {"report", "r", "The type of report to be produced. Reports currently available are:\n", "common", "", "array", construct_report_option_description()},
+    {"element", "e", "Filters individual elements(s) from the report. Format: '/<key>/<key>/...'", "hidden", "", "array"}
+  };
+
+  ptree options_ptree;
+  for (const auto& option : options) {
+    options_ptree.push_back(std::make_pair("", option.to_ptree()));
+  }
+
+  subcommand.add_child("options", options_ptree);
+  return subcommand;
+}
+
+ptree 
+smi_base::
+construct_configure_subcommand() const 
+{
+  ptree subcommand;
+  subcommand.put("name", "configure");
+  subcommand.put("type", "common");
+  subcommand.put("description", "Device and host configuration");
+
+  std::vector<option> options = {
+    {"device", "d", "The Bus:Device.Function (e.g., 0000:d8:00.0) device of interest", "common", "", "string"},
+    {"help", "h", "Help to use this sub-command", "common", "", "none"},
+    {"daemon", "", "Update the device daemon configuration", "common", "", "none"},
+    {"purge", "", "Remove the daemon configuration file", "hidden", "", "string"},
+    {"host", "", "IP or hostname for device peer", "common", "", "string"},
+    {"security", "", "Update the security level for the device", "hidden", "", "string"},
+    {"clk_throttle", "", "Enable/disable the device clock throttling", "hidden", "", "string"},
+    {"ct_threshold_power_override", "", "Update the power threshold in watts", "hidden", "", "string"},
+    {"ct_threshold_temp_override", "", "Update the temperature threshold in celsius", "hidden", "", "string"},
+    {"ct_reset", "", "Reset all throttling options", "hidden", "", "string"},
+    {"showx", "", "Display the device configuration settings", "hidden", "", "string"}
+  };
+
+  ptree options_ptree;
+  for (const auto& option : options) {
+    options_ptree.push_back(std::make_pair("", option.to_ptree()));
+  }
+
+  subcommand.add_child("options", options_ptree);
+  return subcommand;
+}
+
+std::string 
+smi_base::
+get_smi_config() const 
+{
+  ptree config;
+  ptree subcommands;
+
+  subcommands.push_back(std::make_pair("", construct_validate_subcommand()));
+  subcommands.push_back(std::make_pair("", construct_examine_subcommand()));
+  subcommands.push_back(std::make_pair("", construct_configure_subcommand()));
+
+  config.add_child("subcommands", subcommands);
+
+  std::ostringstream oss;
+  boost::property_tree::write_json(oss, config, true); // Pretty print with true
+  return oss.str();
+}
+
+std::string
+get_smi_config()
+{
+  xrt_core::smi::smi_base instance;
+
+  return instance.get_smi_config();
+}
+} // namespace xrt_core::smi
diff --git a/src/runtime_src/core/common/smi.h b/src/runtime_src/core/common/smi.h
new file mode 100644
index 00000000000..23e1c8aedc9
--- /dev/null
+++ b/src/runtime_src/core/common/smi.h
@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (C) 2025 Advanced Micro Devices, Inc. All rights reserved.
+
+#pragma once
+// Local include files
+#include "config.h"
+
+// 3rd Party Library - Include Files
+#include <boost/property_tree/ptree.hpp>
+
+#include <string>
+#include <tuple>
+#include <vector>
+
+namespace xrt_core::smi {
+
+using tuple_vector = std::vector<std::tuple<std::string, std::string, std::string>>; 
+
+struct basic_option {
+  std::string name;
+  std::string description;
+  std::string type;
+};
+
+struct option : public basic_option {
+  std::string alias;
+  std::string default_value;
+  std::string value_type;
+  std::vector<basic_option> description_array;
+
+  option(const std::string name, 
+         const std::string alias, 
+         const std::string description,
+         const std::string type, 
+         const std::string default_value, 
+         const std::string value_type, 
+         const std::vector<basic_option>& description_array = {})
+      : basic_option{std::move(name), std::move(description), std::move(type)}, 
+        alias(std::move(alias)), 
+        default_value(std::move(default_value)), 
+        value_type(std::move(value_type)), 
+        description_array(std::move(description_array)) {}
+
+  boost::property_tree::ptree to_ptree() const;
+};
+
+// Each shim's smi class derives from this class
+// and adds its custom functionalities. Currently only validate tests and examine
+// reports differ between each shim but going forward, each shim can define its 
+// custom behavior for xrt-smi as required. This also gives us the flexibility
+// to add device specific xrt-smi behavior.
+class smi_base {
+protected:
+
+  XRT_CORE_COMMON_EXPORT
+  virtual const tuple_vector& 
+  get_validate_test_desc() const;
+
+  XRT_CORE_COMMON_EXPORT
+  virtual const tuple_vector& 
+  get_examine_report_desc() const;
+
+  std::vector<basic_option> 
+  construct_run_option_description() const;
+
+  std::vector<basic_option> 
+  construct_report_option_description() const;
+
+  boost::property_tree::ptree 
+  construct_validate_subcommand() const;
+
+  boost::property_tree::ptree 
+  construct_examine_subcommand() const;
+
+  boost::property_tree::ptree 
+  construct_configure_subcommand() const;
+
+public:
+  XRT_CORE_COMMON_EXPORT
+  std::string get_smi_config() const;
+};
+
+XRT_CORE_COMMON_EXPORT
+std::string get_smi_config();
+
+} // namespace xrt_core::smi
diff --git a/src/runtime_src/core/edge/user/device_linux.cpp b/src/runtime_src/core/edge/user/device_linux.cpp
index 938b6ef73d1..aaf80b5001f 100644
--- a/src/runtime_src/core/edge/user/device_linux.cpp
+++ b/src/runtime_src/core/edge/user/device_linux.cpp
@@ -5,6 +5,7 @@
 #include "xrt.h"
 #include "zynq_dev.h"
 #include "aie_sys_parser.h"
+#include "smi.h"
 
 #include "core/common/debug_ip.h"
 #include "core/common/query_requests.h"
@@ -678,6 +679,30 @@ struct am_counter
   }
 };
 
+struct xrt_smi_config
+{
+  using result_type = std::any;
+
+  static result_type
+  get(const xrt_core::device* device, key_type key, const std::any& reqType)
+  {
+    if (key != key_type::xrt_smi_config)
+      throw xrt_core::query::no_such_key(key, "Not implemented");
+
+    std::string xrt_smi_config;
+    const auto xrt_smi_config_type = std::any_cast<xrt_core::query::xrt_smi_config::type>(reqType);
+    switch (xrt_smi_config_type) {
+    case xrt_core::query::xrt_smi_config::type::options_config:
+      xrt_smi_config = shim_edge::smi::get_smi_config();
+      break;
+    default:
+      throw xrt_core::query::no_such_key(key, "Not implemented");
+    }
+
+    return xrt_smi_config;
+  }
+};
+
 struct asm_counter
 {
   using result_type = query::asm_counter::result_type;
@@ -1058,6 +1083,7 @@ initialize_query_table()
   emplace_func4_request<query::aim_counter,             aim_counter>();
   emplace_func4_request<query::am_counter,              am_counter>();
   emplace_func4_request<query::asm_counter,             asm_counter>();
+  emplace_func4_request<query::xrt_smi_config,          xrt_smi_config>();
   emplace_func4_request<query::lapc_status,             lapc_status>();
   emplace_func4_request<query::spc_status,              spc_status>();
   emplace_func4_request<query::accel_deadlock_status,   accel_deadlock_status>();
diff --git a/src/runtime_src/core/edge/user/smi.cpp b/src/runtime_src/core/edge/user/smi.cpp
new file mode 100644
index 00000000000..a58808da4eb
--- /dev/null
+++ b/src/runtime_src/core/edge/user/smi.cpp
@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (C) 2025 Advanced Micro Devices, Inc. All rights reserved.
+#include "smi.h"
+
+namespace shim_edge::smi {
+
+const std::vector<std::tuple<std::string, std::string, std::string>>& 
+smi_edge::
+get_validate_test_desc() const 
+{
+  static const std::vector<std::tuple<std::string, std::string, std::string>> validate_test_desc = {
+    {"aux-connection", "Check if auxiliary power is connected", "common"},
+    {"dma", "Run dma test", "common"},
+    {"thostmem-bw", "Run 'bandwidth kernel' when host memory is enabled", "common"},
+    {"m2m", "Run M2M test", "common"},
+    {"mem-bw", "Run 'bandwidth kernel' and check the throughput", "common"},
+    {"p2p", "Run P2P test", "common"},
+    {"pcie-link", "Check if PCIE link is active", "common"},
+    {"sc-version","Check if SC firmware is up-to-date", "common"},
+    {"verify", "Run 'Hello World' kernel test", "common"}
+  };
+  return validate_test_desc;
+}
+
+const std::vector<std::tuple<std::string, std::string, std::string>>& 
+smi_edge::
+get_examine_report_desc() const 
+{
+  static const std::vector<std::tuple<std::string, std::string, std::string>> examine_report_desc = {
+    {"aie", "AIE metadata in xclbin", "common"},
+    {"aiemem", "AIE memory tile information", "common"},
+    {"aieshim", "AIE shim tile status", "common"},
+    {"debug-ip-status", "Status of Debug IPs present in xclbin loaded on device", "common"},
+    {"dynamic-regions", "Information about the xclbin and the compute units", "common"},
+    {"electrical", "Electrical and power sensors present on the device", "common"},
+    {"error", "Asyncronus Error present on the device", "common"},
+    {"firewall", "Firewall status", "common"},
+    {"mailbox", "Mailbox metrics of the device", "common"},
+    {"mechanical", "Mechanical sensors on and surrounding the device", "common"},
+    {"memory", "Memory information present on the device", "common"},
+    {"pcie-info", "Pcie information of the device", "common"},
+    {"qspi-status", "QSPI write protection status", "common"},
+    {"thermal", "Thermal sensors present on the device", "common"}
+  };
+  return examine_report_desc;
+}
+
+std::string
+get_smi_config()
+{
+  // Create an instance of the derived class
+  shim_edge::smi::smi_edge smi_instance;
+
+  // Call the get_smi_config method
+  return smi_instance.get_smi_config();
+}
+} // namespace shim_edge::smi
diff --git a/src/runtime_src/core/edge/user/smi.h b/src/runtime_src/core/edge/user/smi.h
new file mode 100644
index 00000000000..f532e2c34e8
--- /dev/null
+++ b/src/runtime_src/core/edge/user/smi.h
@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (C) 2025 Advanced Micro Devices, Inc. All rights reserved.
+
+#include <string>
+#include "core/common/smi.h"
+
+namespace shim_edge::smi {
+
+class smi_edge : public xrt_core::smi::smi_base {
+protected:
+  const std::vector<std::tuple<std::string, std::string, std::string>>& 
+  get_validate_test_desc() const override;
+
+  const std::vector<std::tuple<std::string, std::string, std::string>>& 
+  get_examine_report_desc() const override;
+
+};
+
+/* This API can be device specific since this is used by the shim*/
+std::string get_smi_config();
+} // namespace shim_edge::smi
diff --git a/src/runtime_src/core/pcie/linux/CMakeLists.txt b/src/runtime_src/core/pcie/linux/CMakeLists.txt
index 787396f51e9..b7dc2001884 100644
--- a/src/runtime_src/core/pcie/linux/CMakeLists.txt
+++ b/src/runtime_src/core/pcie/linux/CMakeLists.txt
@@ -16,8 +16,8 @@ add_library(core_pcielinux_objects OBJECT
   pcidev.cpp
   pcidrv.cpp
   shim.cpp
-  system_linux.cpp
   smi.cpp
+  system_linux.cpp
   )
 
 target_compile_definitions(core_pcielinux_objects
diff --git a/src/runtime_src/core/pcie/linux/device_linux.cpp b/src/runtime_src/core/pcie/linux/device_linux.cpp
index d6da96ff862..4baa5529c84 100644
--- a/src/runtime_src/core/pcie/linux/device_linux.cpp
+++ b/src/runtime_src/core/pcie/linux/device_linux.cpp
@@ -916,11 +916,12 @@ struct xrt_smi_config
   {
     if (key != key_type::xrt_smi_config)
       throw xrt_core::query::no_such_key(key, "Not implemented");
+
     std::string xrt_smi_config;
     const auto xrt_smi_config_type = std::any_cast<xrt_core::query::xrt_smi_config::type>(reqType);
     switch (xrt_smi_config_type) {
     case xrt_core::query::xrt_smi_config::type::options_config:
-      xrt_smi_config = xrt_core::smi::get_smi_config();
+      xrt_smi_config = shim_pcie::smi::get_smi_config();
       break;
     default:
       throw xrt_core::query::no_such_key(key, "Not implemented");
diff --git a/src/runtime_src/core/pcie/linux/smi.cpp b/src/runtime_src/core/pcie/linux/smi.cpp
index 0cac074666a..7478326a11d 100644
--- a/src/runtime_src/core/pcie/linux/smi.cpp
+++ b/src/runtime_src/core/pcie/linux/smi.cpp
@@ -2,418 +2,51 @@
 // Copyright (C) 2025 Advanced Micro Devices, Inc. All rights reserved.
 #include "smi.h"
 
-namespace xrt_core::smi {
+namespace shim_pcie::smi {
 
-static constexpr std::string_view xrt_smi_config =
- R"(
- {
-  "subcommands":
-  [{
-    "name" : "validate",
-    "description" : "Validates the given device by executing the platform's validate executable.",
-    "tag" : "basic",
-    "options" :
-    [
-      {
-        "name": "device",
-        "alias": "d",
-        "description": "The Bus:Device.Function (e.g., 0000:d8:00.0) device of interest",
-        "tag": "basic",
-        "default_value": "",
-        "option_type": "common", 
-        "value_type" : "string"
-      },
-      {
-        "name": "format",
-        "alias": "f",
-        "description": "Report output format",
-        "tag": "basic",
-        "default_value": "JSON",
-        "option_type": "common", 
-        "value_type" : "string"
-      },
-      {
-        "name": "output",
-        "alias": "o",
-        "description" : "Direct the output to the given file",
-        "tag": "basic",
-        "default_value": "",
-        "option_type": "common", 
-        "value_type" : "string"
-      },
-      {
-        "name": "help",
-        "alias": "h",
-        "description" : "Help to use this sub-command",
-        "tag": "basic",
-        "default_value": "",
-        "option_type": "common", 
-        "value_type" : "none"
-      },
-      {
-        "name" : "run",
-        "alias" : "r",
-        "description" : ["Run a subset of the test suite. Valid options are:",
-                         "\n\taie                       - Run AIE PL test",
-                         "\n\taux-connection            - Check if auxiliary power is connected",
-                         "\n\tdma                       - Run dma test",
-                         "\n\thostmem-bw                - Run 'bandwidth kernel' when host memory is",
-                         "\n\t                            enabled",
-                         "\n\tm2m                       - Run M2M test",
-                         "\n\tmem-bw                    - Run 'bandwidth kernel' and check the",
-                         "\n\t                            throughput",
-                         "\n\tp2p                       - Run P2P test",
-                         "\n\tpcie-link                 - Check if PCIE link is active",
-                         "\n\tsc-version                - Check if SC firmware is up-to-date",
-                         "\n\tverify                    - Run 'Hello World' kernel test"
-                         ],
-        "tag" : "basic",
-        "option_type": "common",
-        "value_type" : "array",
-        "options" : [
-          {
-            "name" : "aie",
-            "tag" : "basic",
-            "description" : "Run AIE PL test"
-          },
-          {
-            "name" : "aux-connection",
-            "tag" : "basic",
-            "description" : "Check if auxiliary power is connected"
-          },
-          {
-            "name" : "dma",
-            "tag" : "basic",
-            "description" : "Run dma test"
-          },
-          {
-            "name" : "hostmem-bw",
-            "tag" : "basic",
-            "description" : "Run 'bandwidth kernel' when host memory is enabled"
-          },
-          {
-            "name" : "m2m",
-            "tag" : "basic",
-            "description" : "Run M2M test"
-          },
-          {
-            "name" : "mem-bw",
-            "tag" : "basic",
-            "description" : "Run 'bandwidth kernel' and check the throughput"
-          },
-          {
-            "name" : "p2p",
-            "tag" : "basic",
-            "description" : "Run P2P test"
-          },
-          {
-            "name" : "pcie-link",
-            "tag" : "basic",
-            "description" : "Check if PCIE link is active"
-          },
-          {
-            "name" : "tsc-version",
-            "tag" : "advanced",
-            "description" : "Check if SC firmware is up-to-date"
-          },
-          {
-            "name" : "verify",
-            "tag" : "advanced",
-            "description" : "Run 'Hello World' kernel test"
-          }
-        ]
-      },
-      {
-        "name" : "path",
-        "alias" : "p",
-        "description" : "Path to the directory containing validate xclbins",
-        "tag" : "basic",
-        "default_value": "",
-        "option_type": "hidden",
-        "value_type" : "string"
-      },
-      {
-        "name" : "param",
-        "description" : "Extended parameter for a given test. Format: <test-name>:<key>:<value>",
-        "tag" : "basic",
-        "option_type": "hidden",
-        "default_value": "",
-        "value_type" : "string"
-      },
-      {
-        "name" : "pmode",
-        "description" : "Specify which power mode to run the benchmarks in. Note: Some tests might be unavailable for some modes",
-        "tag" : "basic",
-        "option_type": "hidden",
-        "default_value": "",
-        "value_type" : "string"
-      }
-    ]
-  },
-  {
-    "name" : "examine",
-    "tag" : "basic",
-    "description": "This command will 'examine' the state of the system/device and will generate a report of interest in a text or JSON format.",
-    "options":
-    [
-      {
-        "name": "device",
-        "alias": "d",
-        "description": "The Bus:Device.Function (e.g., 0000:d8:00.0) device of interest",
-        "tag": "basic",
-        "default_value": "",
-        "option_type": "common",
-        "value_type": "string"
-      },
-      {
-        "name": "format",
-        "alias": "f",
-        "description": ["Report output format. Valid values are:",
-                        "\n\tJSON        - Latest JSON schema",
-                        "\n\tJSON-2020.2 - JSON 2020.2 schema"
-                        ],
-        "tag": "basic",
-        "default_value": "",
-        "option_type": "common",
-        "value_type": "string"
-      },
-      {
-        "name": "output",
-        "alias": "o",
-        "description" : "Direct the output to the given file",
-        "tag": "basic",
-        "default_value": "",
-        "option_type": "common", 
-        "value_type" : "string"
-      },
-      {
-        "name": "help",
-        "alias": "h",
-        "description" : "Help to use this sub-command",
-        "tag": "basic",
-        "default_value": "",
-        "option_type": "common", 
-        "value_type" : "none"
-      },
-      {
-        "name": "report",
-        "alias": "r",
-        "description": ["The type of report to be produced. Reports currently available are:",
-                         "\n\taie             - AIE metadata in xclbin",
-                         "\n\taiemem          - AIE memory tile information",
-                         "\n\taieshim         - AIE shim tile status",
-                         "\n\tdebug-ip-status - Status of Debug IPs present in xclbin loaded on device",
-                         "\n\tdynamic-regions - Information about the xclbin and the compute units",
-                         "\n\telectrical      - Electrical and power sensors present on the device",
-                         "\n\terror           - Asyncronus Error present on the device",
-                         "\n\tfirewall        - Firewall status",
-                         "\n\tmailbox         - Mailbox metrics of the device",
-                         "\n\tmechanical      - Mechanical sensors on and surrounding the device",
-                         "\n\tmemory          - Memory information present on the device",
-                         "\n\tpcie-info       - Pcie information of the device",
-                         "\n\tqspi-status     - QSPI write protection status",
-                         "\n\tthermal         - Thermal sensors present on the device"
-                        ],
-        "tag": "basic",
-        "option_type": "common",
-        "value_type": "array",
-        "options": [
-          {
-            "name": "aie",
-            "tag": "basic",
-            "description": "AIE metadata in xclbin"
-          },
-          {
-            "name": "aiemem",
-            "tag": "basic",
-            "description": "AIE memory tile information"
-          },
-          {
-            "name": "aieshim",
-            "tag": "basic",
-            "description": "AIE shim tile status"
-          },
-          {
-            "name": "debug-ip-status",
-            "tag": "basic",
-            "description": "Status of Debug IPs present in xclbin loaded on device"
-          },
-          {
-            "name": "dynamic-regions",
-            "tag": "basic",
-            "description": "Information about the xclbin and the compute units"
-          },
-          {
-            "name": "electrical",
-            "tag": "basic",
-            "description": "Electrical and power sensors present on the device"
-          },
-          {
-            "name": "error",
-            "tag": "basic",
-            "description": "Asyncronus Error present on the device"
-          },
-          {
-            "name": "firewall",
-            "tag": "basic",
-            "description": "Firewall status"
-          },
-          {
-            "name": "mailbox",
-            "tag": "basic",
-            "description": "Mailbox metrics of the device"
-          },
-          {
-            "name": "mechanical",
-            "tag": "basic",
-            "description": "Mechanical sensors on and surrounding the device"
-          },
-          {
-            "name": "memory",
-            "tag": "basic",
-            "description": "Memory information present on the device"
-          },
-          {
-            "name": "pcie-info",
-            "tag": "basic",
-            "description": "Pcie information of the device"
-          },
-          {
-            "name": "qspi-status",
-            "tag": "basic",
-            "description": "QSPI write protection status"
-          },
-          {
-            "name": "thermal",
-            "tag": "basic",
-            "description": "Thermal sensors present on the device"
-          }
-        ]
-      },
-      {
-        "name": "element",
-        "alias": "e",
-        "description" : "Filters individual elements(s) from the report. Format: '/<key>/<key>/...'",
-        "tag": "basic",
-        "option_type": "hidden", 
-        "value_type" : "array"
-      } 
-    ]
-  },
-  {
-    "name" : "configure",
-    "tag" : "devl",
-    "description" : "Device and host configuration.",
-    "options" :
-    [
-      {
-        "name": "device",
-        "alias": "d",
-        "description": "The Bus:Device.Function (e.g., 0000:d8:00.0) device of interest",
-        "tag": "basic",
-        "default_value": "",
-        "option_type": "common",
-        "value_type": "string"
-      },
-      {
-        "name": "help",
-        "alias": "h",
-        "description" : "Help to use this sub-command",
-        "tag": "basic",
-        "default_value": "",
-        "option_type": "common", 
-        "value_type" : "none"
-      },
-      {
-        "name": "daemon",
-        "alias": "",
-        "description" : "Update the device daemon configuration",
-        "tag": "basic",
-        "default_value": "",
-        "option_type": "hidden", 
-        "value_type" : "none"
-      },
-      {
-        "name": "purge",
-        "alias": "",
-        "description": "Remove the daemon configuration file",
-        "tag": "basic",
-        "default_value": "",
-        "option_type": "hidden",
-        "value_type": "string"
-      },
-      {
-        "name": "host",
-        "alias": "",
-        "description" : "IP or hostname for device peer",
-        "tag": "basic",
-        "default_value": "",
-        "option_type": "hidden", 
-        "value_type" : "string"
-      },
-      {
-        "name": "security",
-        "alias": "",
-        "description" : "Update the security level for the device",
-        "tag": "basic",
-        "default_value": "",
-        "option_type": "hidden", 
-        "value_type" : "string"
-      },
-      {
-        "name": "clk_throttle",
-        "alias": "",
-        "description" : "Enable/disable the device clock throttling",
-        "tag": "basic",
-        "default_value": "",
-        "option_type": "hidden", 
-        "value_type" : "string"
-      },
-      {
-        "name": "ct_threshold_power_override",
-        "alias": "",
-        "description" : "Update the power threshold in watts",
-        "tag": "basic",
-        "default_value": "",
-        "option_type": "hidden", 
-        "value_type" : "string"
-      },
-      {
-        "name": "ct_threshold_temp_override",
-        "alias": "",
-        "description" : "Update the temperature threshold in celsius",
-        "tag": "basic",
-        "default_value": "",
-        "option_type": "hidden", 
-        "value_type" : "string"
-      },
-      {
-        "name": "ct_reset",
-        "alias": "",
-        "description" : "Reset all throttling options",
-        "tag": "basic",
-        "default_value": "",
-        "option_type": "hidden", 
-        "value_type" : "string"
-      },
-      {
-        "name": "showx",
-        "alias": "",
-        "description" : "Display the device configuration settings",
-        "tag": "basic",
-        "default_value": "",
-        "option_type": "hidden", 
-        "value_type" : "string"
-      }
-    ]
-  }]
+const std::vector<std::tuple<std::string, std::string, std::string>>& 
+smi_pcie::get_validate_test_desc() const {
+  static const std::vector<std::tuple<std::string, std::string, std::string>> validate_test_desc = {
+    {"aux-connection", "Check if auxiliary power is connected", "common"},
+    {"dma", "Run dma test", "common"},
+    {"thostmem-bw", "Run 'bandwidth kernel' when host memory is enabled", "common"},
+    {"m2m", "Run M2M test", "common"},
+    {"mem-bw", "Run 'bandwidth kernel' and check the throughput", "common"},
+    {"p2p", "Run P2P test", "common"},
+    {"pcie-link", "Check if PCIE link is active", "common"},
+    {"sc-version","Check if SC firmware is up-to-date", "common"},
+    {"verify", "Run 'Hello World' kernel test", "common"}
+  };
+  return validate_test_desc;
 }
-)"; 
 
+const std::vector<std::tuple<std::string, std::string, std::string>>& 
+smi_pcie::get_examine_report_desc() const {
+  static const std::vector<std::tuple<std::string, std::string, std::string>> examine_report_desc = {
+    {"aie", "AIE metadata in xclbin", "common"},
+    {"aiemem", "AIE memory tile information", "common"},
+    {"aieshim", "AIE shim tile status", "common"},
+    {"debug-ip-status", "Status of Debug IPs present in xclbin loaded on device", "common"},
+    {"dynamic-regions", "Information about the xclbin and the compute units", "common"},
+    {"electrical", "Electrical and power sensors present on the device", "common"},
+    {"error", "Asyncronus Error present on the device", "common"},
+    {"firewall", "Firewall status", "common"},
+    {"mailbox", "Mailbox metrics of the device", "common"},
+    {"mechanical", "Mechanical sensors on and surrounding the device", "common"},
+    {"memory", "Memory information present on the device", "common"},
+    {"pcie-info", "Pcie information of the device", "common"},
+    {"qspi-status", "QSPI write protection status", "common"},
+    {"thermal", "Thermal sensors present on the device", "common"}
+  };
+  return examine_report_desc;
+}
+
+std::string
+get_smi_config(){
+  // Create an instance of the derived class
+  shim_pcie::smi::smi_pcie smi_instance;
 
-std::string 
-get_smi_config()
-{
-  return std::string(xrt_smi_config);
+  // Call the get_smi_config method
+  return smi_instance.get_smi_config();
 }
-} // namespace xrt_core::smi
+} // namespace shim_pcie::smi
diff --git a/src/runtime_src/core/pcie/linux/smi.h b/src/runtime_src/core/pcie/linux/smi.h
index d986f07b555..dc373d56a46 100644
--- a/src/runtime_src/core/pcie/linux/smi.h
+++ b/src/runtime_src/core/pcie/linux/smi.h
@@ -2,10 +2,16 @@
 // Copyright (C) 2025 Advanced Micro Devices, Inc. All rights reserved.
 
 #include <string>
+#include "core/common/smi.h"
 
-namespace xrt_core::smi {
+namespace shim_pcie::smi {
 
-std::string 
-get_smi_config();
+class smi_pcie : public xrt_core::smi::smi_base {
+protected:
+  const std::vector<std::tuple<std::string, std::string, std::string>>& get_validate_test_desc() const override;
+  const std::vector<std::tuple<std::string, std::string, std::string>>& get_examine_report_desc() const override;
+};
 
-} // namespace xrt_core::smi
+/* This API can be device specific since this is used by the shim*/
+std::string get_smi_config();
+} // namespace shim_pcie::smi
diff --git a/src/runtime_src/core/tools/common/SubCmd.cpp b/src/runtime_src/core/tools/common/SubCmd.cpp
index 757a8b50fa4..b88f586c837 100644
--- a/src/runtime_src/core/tools/common/SubCmd.cpp
+++ b/src/runtime_src/core/tools/common/SubCmd.cpp
@@ -167,15 +167,7 @@ SubCmd::checkForSubOption(const boost::program_options::variables_map& vm, const
   return option;
 }
 
-void
-SubCmd::setOptionConfig(const boost::property_tree::ptree &config)
-{
-  m_jsonConfig = SubCmdJsonObjects::JsonConfig(config.get_child("subcommands"), getName());
-  try{
-    m_jsonConfig.addProgramOptions(m_commonOptions, "common", getName());
-    m_jsonConfig.addProgramOptions(m_hiddenOptions, "hidden", getName());
-  } 
-  catch (const std::exception& e) {
-    std::cerr << "Error: " << e.what() << std::endl;
-  }
+void 
+SubCmd::setOptionConfig(const boost::property_tree::ptree &/*config*/) {
+  /*Stub. Should be implemented by derived classes on per need basis*/
 }
diff --git a/src/runtime_src/core/tools/common/SubCmd.h b/src/runtime_src/core/tools/common/SubCmd.h
index 7cef998fd7e..bcadb10a25f 100644
--- a/src/runtime_src/core/tools/common/SubCmd.h
+++ b/src/runtime_src/core/tools/common/SubCmd.h
@@ -22,6 +22,7 @@ class SubCmd : public JSONConfigurable {
 
  public:
    virtual void execute(const SubCmdOptions &_options) const = 0;
+   virtual void setOptionConfig(const boost::property_tree::ptree &config);
 
  public:
    const std::string &getName() const { return m_subCmdName; };
@@ -39,7 +40,6 @@ class SubCmd : public JSONConfigurable {
    const std::string & getExecutableName() const {return m_executableName; };
 
    void setGlobalOptions(const boost::program_options::options_description &globalOptions) { m_globalOptions.add(globalOptions); };
-   void setOptionConfig(const boost::property_tree::ptree &config);
 
  protected:
    const boost::program_options::options_description & getGlobalOptions() const { return m_globalOptions; };
diff --git a/src/runtime_src/core/tools/common/SubCmdConfigureInternal.cpp b/src/runtime_src/core/tools/common/SubCmdConfigureInternal.cpp
index 5493f62abd1..22f5455f8f1 100644
--- a/src/runtime_src/core/tools/common/SubCmdConfigureInternal.cpp
+++ b/src/runtime_src/core/tools/common/SubCmdConfigureInternal.cpp
@@ -425,3 +425,15 @@ SubCmdConfigureInternal::fill_option_values(const boost::program_options::variab
   options.m_showx = vm.count("showx") ? vm["showx"].as<bool>() : false;
 }
 
+void
+SubCmdConfigureInternal::setOptionConfig(const boost::property_tree::ptree &config)
+{
+  m_jsonConfig = SubCmdJsonObjects::JsonConfig(config.get_child("subcommands"), getName());
+  try{
+    m_jsonConfig.addProgramOptions(m_commonOptions, "common", getName());
+    m_jsonConfig.addProgramOptions(m_hiddenOptions, "hidden", getName());
+  } 
+  catch (const std::exception& e) {
+    std::cerr << "Error: " << e.what() << std::endl;
+  }
+}
diff --git a/src/runtime_src/core/tools/common/SubCmdConfigureInternal.h b/src/runtime_src/core/tools/common/SubCmdConfigureInternal.h
index 5c22878fdfc..dfbac540932 100644
--- a/src/runtime_src/core/tools/common/SubCmdConfigureInternal.h
+++ b/src/runtime_src/core/tools/common/SubCmdConfigureInternal.h
@@ -28,6 +28,7 @@ struct SubCmdConfigureOptions {
 class SubCmdConfigureInternal : public SubCmd {
  public:
   virtual void execute(const SubCmdOptions &_options) const;
+  virtual void setOptionConfig(const boost::property_tree::ptree &config) override;
 
  public:
   SubCmdConfigureInternal(bool _isHidden, bool _isDepricated, bool _isPreliminary, bool _isUserDomain, const boost::property_tree::ptree& configurations);
diff --git a/src/runtime_src/core/tools/common/SubCmdExamineInternal.cpp b/src/runtime_src/core/tools/common/SubCmdExamineInternal.cpp
index 00b04bba802..cd785fbbbc9 100644
--- a/src/runtime_src/core/tools/common/SubCmdExamineInternal.cpp
+++ b/src/runtime_src/core/tools/common/SubCmdExamineInternal.cpp
@@ -221,3 +221,16 @@ void SubCmdExamineInternal::fill_option_values(const po::variables_map& vm, SubC
   options.m_help = vm.count("help") ? vm["help"].as<bool>() : false;
   options.m_elementsFilter = vm.count("element") ? vm["element"].as<std::vector<std::string>>() : std::vector<std::string>(); 
 }
+
+void
+SubCmdExamineInternal::setOptionConfig(const boost::property_tree::ptree &config)
+{
+  m_jsonConfig = SubCmdJsonObjects::JsonConfig(config.get_child("subcommands"), getName());
+  try{
+    m_jsonConfig.addProgramOptions(m_commonOptions, "common", getName());
+    m_jsonConfig.addProgramOptions(m_hiddenOptions, "hidden", getName());
+  } 
+  catch (const std::exception& e) {
+    std::cerr << "Error: " << e.what() << std::endl;
+  }
+}
diff --git a/src/runtime_src/core/tools/common/SubCmdExamineInternal.h b/src/runtime_src/core/tools/common/SubCmdExamineInternal.h
index c800e193f65..1df78feb848 100644
--- a/src/runtime_src/core/tools/common/SubCmdExamineInternal.h
+++ b/src/runtime_src/core/tools/common/SubCmdExamineInternal.h
@@ -19,6 +19,7 @@ struct SubCmdExamineOptions {
 class SubCmdExamineInternal : public SubCmd {
  public:
   virtual void execute(const SubCmdOptions &_options) const;
+  virtual void setOptionConfig(const boost::property_tree::ptree &config) override;
 
  public:
   SubCmdExamineInternal(bool _isHidden, bool _isDepricated, bool _isPreliminary, bool _isUserDomain, const boost::property_tree::ptree& configurations);
diff --git a/src/runtime_src/core/tools/common/SubCmdJsonObjects.cpp b/src/runtime_src/core/tools/common/SubCmdJsonObjects.cpp
index 79d848ca951..c7db983e177 100644
--- a/src/runtime_src/core/tools/common/SubCmdJsonObjects.cpp
+++ b/src/runtime_src/core/tools/common/SubCmdJsonObjects.cpp
@@ -3,77 +3,53 @@
 
 #include <iostream>
 #include <string>
-#include <unordered_map>
+#include <map>
 #include <numeric>
 
 #include <boost/property_tree/ptree.hpp>
 #include <boost/program_options.hpp>
 #include "SubCmdJsonObjects.h"
+#include "tools/common/XBHelpMenus.h"
 
 namespace SubCmdJsonObjects {
 
 static constexpr std::string_view const_name_literal = "name";
 static constexpr std::string_view const_description_literal = "description";
-static constexpr std::string_view const_tag_literal = "tag";
+static constexpr std::string_view const_type_literal = "type";
 static constexpr std::string_view const_alias_literal = "alias";
 static constexpr std::string_view const_default_value_literal = "default_value";
-static constexpr std::string_view const_option_type_literal = "option_type";
 static constexpr std::string_view const_value_type_literal = "value_type";
 static constexpr std::string_view const_options_literal = "options";
+static constexpr std::string_view const_description_array_literal = "description_array";
+static constexpr std::string_view const_hidden_literal = "hidden";
 
-static std::unordered_map<std::string, ValueType> valueTypeMap = {
+static std::map<std::string, ValueType> valueTypeMap = {
   {"bool", ValueType::boolean},
   {"string", ValueType::string},
   {"array", ValueType::array},
   {"none", ValueType::none}
 };
 
-OptionBasic::OptionBasic(const pt::ptree& configurations)
-  : m_name(configurations.get<std::string>(std::string(const_name_literal))), 
-    m_description(concatenate(configurations, std::string(const_description_literal))), 
-    m_tag(configurations.get<std::string>(std::string(const_tag_literal)))
-    {}
-
-std::string
-OptionBasic::concatenate(const pt::ptree& pt, const std::string& path) const
-{
-  try {
-    const auto& child = pt.get_child(path);
-
-    // Check if the path is a list
-    if (child.empty()) {
-      // Return the single string value
-      return pt.get<std::string>(path);
-    }
-    else {
-      // If the child has size, it means its a list. Concatenate strings from the list
-      return std::accumulate(child.begin(), child.end(), std::string(),
-        [](const std::string& acc, const boost::property_tree::ptree::value_type& item) {
-          return acc + item.second.get_value<std::string>();
-        });
-    }
-  } catch (const pt::ptree_error& e) {
-    std::cerr << "Error: " << e.what() << std::endl;
-    return "";
-  }
-}
+OptionBasic::OptionBasic(const pt::ptree& configurations) : 
+  m_name(configurations.get<std::string>(std::string(const_name_literal))),
+  m_description(configurations.get<std::string>(std::string(const_description_literal))),
+  m_type(configurations.get<std::string>(std::string(const_type_literal))) {}
 
 void
 OptionBasic::printOption() const
 {
   std::cout << "Name: " << m_name << std::endl;
   std::cout << "Description: " << m_description << std::endl;
-  std::cout << "Tag: " << m_tag << std::endl;
+  std::cout << "Type: " << m_type << std::endl;
 }
 
 SubCommandOption::SubCommandOption(const pt::ptree& configurations):
     OptionBasic(configurations),
     m_alias(configurations.get<std::string>(std::string(const_alias_literal), "")),
     m_defaultValue(configurations.get<std::string>(std::string(const_default_value_literal), "")),
-    m_optionType(configurations.get<std::string>(std::string(const_option_type_literal), "")),
     m_valueType(configurations.get<std::string>(std::string(const_value_type_literal), "")),
-    m_ptEmpty(pt::ptree()),
-    m_subOptionMap(createBasicOptions(configurations.get_child(std::string(const_options_literal), m_ptEmpty))){}
+    m_description_array(createDescriptionArray(configurations)),
+    m_ptEmpty(pt::ptree()) {}
 
 /**
  * Adds the sub-command option to the options description.
@@ -83,42 +59,53 @@ SubCommandOption::SubCommandOption(const pt::ptree& configurations):
  * If the value type is invalid, an exception is thrown.
  */
 void 
-SubCommandOption::addProgramOption(po::options_description& options, const std::string& optionsType) 
+SubCommandOption::addProgramOption(po::options_description& options, const std::string& type) 
 {
-  if (m_optionType != optionsType) return;
+  if (m_type != type) return;
 
   auto valueType = valueTypeMap.find(m_valueType);
   if (valueType == valueTypeMap.end()) {
     throw std::runtime_error("Invalid value type for option " + m_name);
   }
+
+  std::string description = m_description;
+  if (!m_description_array.empty()) {
+    std::vector<std::pair<std::string, std::string>> temp;
+    for (const auto& desc : m_description_array) {
+      if (desc.getType() == const_hidden_literal) continue;
+      temp.emplace_back(std::make_pair<std::string, std::string>(desc.getName(), desc.getDescription()));
+    }
+    description += XBUtilities::create_suboption_list_string(temp);
+  }
+
   switch (valueType->second){
     case ValueType::boolean:
     {
       auto defaultVal = m_defaultValue == "true" ? true : false;
       options.add_options()((m_name + "," + m_alias).c_str()
                             , po::value<bool>()->default_value(defaultVal)
-                            , m_description.c_str());
+                            , description.c_str());
       break;
     }
     case ValueType::string:
     {
       options.add_options()((m_name + "," + m_alias).c_str()
                             , po::value<std::string>()->implicit_value(m_defaultValue)
-                            , m_description.c_str());
+                            , description.c_str());
       break;
     }
     case ValueType::array:
     {
       options.add_options()((m_name + "," + m_alias).c_str()
                             , po::value<std::vector<std::string>>()->multitoken()->zero_tokens()
-                            , m_description.c_str());
+                            , description.c_str());
       break;
     }
     case ValueType::none:
     {
       options.add_options()((m_name + "," + m_alias).c_str()
                             , po::bool_switch()
-                            , m_description.c_str());
+                            , description.c_str());
       break;
     }
     default:
@@ -126,29 +113,25 @@ SubCommandOption::addProgramOption(po::options_description& options, const std::
   }
 }
 
-std::unordered_map<std::string, OptionBasic>
-SubCommandOption::createBasicOptions(const pt::ptree& pt)
+std::vector<OptionBasic>
+SubCommandOption::createDescriptionArray(const pt::ptree& pt)
 {
-  std::unordered_map<std::string, OptionBasic> optionMap;
-  for (const auto& [key, value] : pt) {
-    optionMap.emplace(value.get<std::string>(std::string(const_name_literal)), OptionBasic(value));
+  std::vector<OptionBasic> optionVector;
+  if (pt.get_child_optional("description_array")) {
+    for (const auto& item : pt.get_child("description_array")) {
+      optionVector.emplace_back(item.second);
+    }
   }
-  return optionMap;
+  return optionVector;
 }
 
 void
 SubCommandOption::printOption() const
 {
-  std::cout << "Name: " << m_name << std::endl;
-  std::cout << "Description: " << m_description << std::endl;
-  std::cout << "Tag: " << m_tag << std::endl;
+  OptionBasic::printOption();
   std::cout << "Alias: " << m_alias << std::endl;
   std::cout << "Default Value: " << m_defaultValue << std::endl;
-  std::cout << "Option Type: " << m_optionType << std::endl;
   std::cout << "Value Type: " << m_valueType << std::endl;
-  for (const auto& [key, value] : m_subOptionMap) {
-    value.printOption();
-  }
 }
 
 SubCommand::SubCommand(const pt::ptree& configurations) :
@@ -156,10 +139,10 @@ SubCommand::SubCommand(const pt::ptree& configurations) :
   m_optionMap(createSubCommandOptions(configurations.get_child(std::string(const_options_literal)))) 
   {}
 
-std::unordered_map<std::string, SubCommandOption>
+std::map<std::string, SubCommandOption>
 SubCommand::createSubCommandOptions(const pt::ptree& pt)
 {
-  std::unordered_map<std::string, SubCommandOption> optionMap;
+  std::map<std::string, SubCommandOption> optionMap;
   for (const auto& [key, value] : pt) {
     optionMap.emplace(value.get<std::string>(std::string(const_name_literal)), SubCommandOption(value));
   }
@@ -179,10 +162,10 @@ SubCommand::addProgramOptions(po::options_description& options, const std::strin
  * This method parses the property tree to create a map of sub-command names to SubCommand objects.
  * Only sub-commands matching the provided subCommand name are included.
  */
-std::unordered_map<std::string, SubCommand>
+std::map<std::string, SubCommand>
 JsonConfig::createSubCommands(const pt::ptree& pt, const std::string& subCommand)
 {
-  std::unordered_map<std::string, SubCommand> subCommandMap;
+  std::map<std::string, SubCommand> subCommandMap;
   for (const auto& [key, value] : pt) {
     if (value.get<std::string>(std::string(const_name_literal)) != subCommand) {
       continue;
@@ -215,7 +198,7 @@ JsonConfig::printConfigurations() const
   for (const auto& [key, value] : m_subCommandMap) {
     std::cout << "Subcommand: " << key << std::endl;
     std::cout << "Description: " << value.getDescription() << std::endl;
-    std::cout << "Tag: " << value.getTag() << std::endl;
+    std::cout << "Type: " << value.getType() << std::endl;
     for (const auto& [key2, value2] : value.getOptionMap()) {
       value2.printOption();
     }
diff --git a/src/runtime_src/core/tools/common/SubCmdJsonObjects.h b/src/runtime_src/core/tools/common/SubCmdJsonObjects.h
index bce0e180973..b0dd266dd4d 100644
--- a/src/runtime_src/core/tools/common/SubCmdJsonObjects.h
+++ b/src/runtime_src/core/tools/common/SubCmdJsonObjects.h
@@ -4,7 +4,7 @@
 #pragma once
 
 #include <string>
-#include <unordered_map>
+#include <map>
 
 #include "boost/property_tree/ptree.hpp"
 #include "boost/program_options.hpp"
@@ -26,16 +26,15 @@ class OptionBasic {
 public:
   std::string m_name;
   std::string m_description;
-  std::string m_tag;
+  std::string m_type;
 
   public:
 
   OptionBasic(const pt::ptree& configurations);
 
-  std::string concatenate(const pt::ptree& pt, const std::string& path) const;
   std::string getName() const { return m_name; }
   std::string getDescription() const { return m_description; }
-  std::string getTag() const { return m_tag; }
+  std::string getType() const { return m_type; }
   void printOption() const;
 };
 
@@ -43,30 +42,17 @@ class OptionBasic {
 class SubCommandOption : public OptionBasic {
   std::string m_alias;
   std::string m_defaultValue;
-  std::string m_optionType;
   std::string m_valueType;
+  std::vector<OptionBasic> m_description_array;
   pt::ptree   m_ptEmpty;
 
-  /*
-  * Map of option name vs SubCommandOption objects. Example:
-  * --run can have multiple option values like latency, throughput etc.
-  * latency : OptionBasic object
-  * throughput : OptionBasic object
-  * .................
-  * df-bw : OptionBasic object
-  */
-  std::unordered_map<std::string, OptionBasic> m_subOptionMap;
-  std::unordered_map<std::string, OptionBasic>
-  createBasicOptions(const pt::ptree& pt);
-
 public:
   SubCommandOption(const pt::ptree& configurations);
 
   std::string getValueType() const { return m_valueType; }
   std::string getAlias() const { return m_alias; }
   std::string getDefaultValue() const { return m_defaultValue; }
-  std::string getOptionType() const { return m_optionType; }
-  std::unordered_map<std::string, OptionBasic> getSubOptionMap() const { return m_subOptionMap; }
+  std::vector<OptionBasic> createDescriptionArray(const pt::ptree& pt);
 
   void addProgramOption(po::options_description& options, const std::string& optionsType);
   void printOption() const;
@@ -80,14 +66,14 @@ class SubCommand : public OptionBasic {
   * .................
   * --run : SubCommandOption object
   */
-  std::unordered_map<std::string, SubCommandOption> m_optionMap;
+  std::map<std::string, SubCommandOption> m_optionMap;
 
-  std::unordered_map<std::string, SubCommandOption>
+  std::map<std::string, SubCommandOption>
   createSubCommandOptions(const pt::ptree& pt);
 
 public:
   SubCommand(const pt::ptree& configurations); 
-  std::unordered_map<std::string,SubCommandOption> getOptionMap() const { return m_optionMap; }
+  std::map<std::string,SubCommandOption> getOptionMap() const { return m_optionMap; }
 
   void addProgramOptions(po::options_description& options, const std::string& optionsType);
 };
@@ -106,8 +92,8 @@ class JsonConfig {
   * configure : SubCommand object
   * examine : SubCommand object 
   */
-  std::unordered_map<std::string, SubCommand> m_subCommandMap;
-  std::unordered_map<std::string, SubCommand>
+  std::map<std::string, SubCommand> m_subCommandMap;
+  std::map<std::string, SubCommand>
   createSubCommands(const pt::ptree& pt, const std::string& subCommand);
 public:
   JsonConfig(const pt::ptree& configurations, const std::string& subCommand)
diff --git a/src/runtime_src/core/tools/common/XBMain.cpp b/src/runtime_src/core/tools/common/XBMain.cpp
index 8bbcae84fbb..7434836fcf8 100644
--- a/src/runtime_src/core/tools/common/XBMain.cpp
+++ b/src/runtime_src/core/tools/common/XBMain.cpp
@@ -5,6 +5,7 @@
 // ------ I N C L U D E   F I L E S -------------------------------------------
 // Local - Include Files
 #include "core/common/system.h"
+#include "core/common/smi.h"
 #include "SubCmd.h"
 #include "XBHelpMenusCore.h"
 #include "XBUtilitiesCore.h"
@@ -190,7 +191,7 @@ void  main_(int argc, char** argv,
   if (device) 
     config = xrt_core::device_query<xrt_core::query::xrt_smi_config>(device, xrt_core::query::xrt_smi_config::type::options_config);
   else 
-    config = XBU::loadDefaultSmiConfig(); 
+    config = xrt_core::smi::get_smi_config(); 
   std::istringstream command_config_stream(config);
   boost::property_tree::read_json(command_config_stream, configTreeMain);
   subCommand->setOptionConfig(configTreeMain);
diff --git a/src/runtime_src/core/tools/common/XBUtilities.cpp b/src/runtime_src/core/tools/common/XBUtilities.cpp
index 0f5d62841f5..b931fbf4a05 100755
--- a/src/runtime_src/core/tools/common/XBUtilities.cpp
+++ b/src/runtime_src/core/tools/common/XBUtilities.cpp
@@ -13,6 +13,7 @@
 #include "common/message.h"
 #include "common/system.h"
 #include "common/sysinfo.h"
+#include "common/smi.h"
 
 // 3rd Party Library - Include Files
 #include <boost/algorithm/string/split.hpp>
@@ -773,337 +774,4 @@ fill_xrt_versions(const boost::property_tree::ptree& pt_xrt,
   catch (...) {
     //no device available
   }
-}
-
-std::string 
-XBUtilities::loadDefaultSmiConfig()
-{
-  return std::string(
-    R"(
-{
-  "subcommands":
-  [{
-    "name" : "validate",
-    "description" : "Validates the given device by executing the platform's validate executable.",
-    "tag" : "basic",
-    "options" :
-    [
-      {
-        "name": "device",
-        "alias": "d",
-        "description": "The Bus:Device.Function (e.g., 0000:d8:00.0) device of interest",
-        "tag": "basic",
-        "default_value": "",
-        "option_type": "common", 
-        "value_type" : "string"
-      },
-      {
-        "name": "format",
-        "alias": "f",
-        "description": "Report output format",
-        "tag": "basic",
-        "default_value": "JSON",
-        "option_type": "common", 
-        "value_type" : "string"
-      },
-      {
-        "name": "output",
-        "alias": "o",
-        "description" : "Direct the output to the given file",
-        "tag": "basic",
-        "default_value": "",
-        "option_type": "common", 
-        "value_type" : "string"
-      },
-      {
-        "name": "help",
-        "alias": "h",
-        "description" : "Help to use this sub-command",
-        "tag": "basic",
-        "default_value": "",
-        "option_type": "common", 
-        "value_type" : "none"
-      },
-      {
-        "name" : "run",
-        "alias" : "r",
-        "description" : ["Run a subset of the test suite. Valid options are:",
-                         "\n\tCommon:",
-                         "\n\t\tall                       - All applicable validate tests will be",
-                         "\n\t\t                            executed (default) ",
-                         "\n\t\tquick                     - Run a subset of top four tests",
-                         "\n\tAIE:",
-                         "\n\t\taie-reconfig-overhead     - Run end-to-end array reconfiguration overhead",
-                         "\n\t\t                            through shim DMA",
-                         "\n\t\tcmd-chain-latency         - Run end-to-end latency test using command",
-                         "\n\t\t                            chaining",
-                         "\n\t\tcmd-chain-throughput      - Run end-to-end throughput test using command",
-                         "\n\t\t                            chaining",
-                         "\n\t\tdf-bw                     - Run bandwidth test on data fabric",
-                         "\n\t\tgemm                      - Measure the TOPS value of GEMM operations",
-                         "\n\t\tlatency                   - Run end-to-end latency test",
-                         "\n\t\tspatial-sharing-overhead  - Run Spatial Sharing Overhead Test",
-                         "\n\t\ttct-all-col               - Measure average TCT processing time for all",
-                         "\n\t\t                            columns",
-                         "\n\t\ttct-one-col               - Measure average TCT processing time for one",
-                         "\n\t\t                            column",
-                         "\n\t\ttemporal-sharing-overhead - Run Temporal Sharing Overhead Test",
-                         "\n\t\tthroughput                - Run end-to-end throughput test",
-                         "\n\tAlveo:",
-                         "\n\t\taie                       - Run AIE PL test",
-                         "\n\t\taux-connection            - Check if auxiliary power is connected",
-                         "\n\t\tdma                       - Run dma test",
-                         "\n\t\thostmem-bw                - Run 'bandwidth kernel' when host memory is",
-                         "\n\t\t                            enabled",
-                         "\n\t\tm2m                       - Run M2M test",
-                         "\n\t\tmem-bw                    - Run 'bandwidth kernel' and check the",
-                         "\n\t\t                            throughput",
-                         "\n\t\tp2p                       - Run P2P test",
-                         "\n\t\tpcie-link                 - Check if PCIE link is active",
-                         "\n\t\tsc-version                - Check if SC firmware is up-to-date",
-                         "\n\t\tverify                    - Run 'Hello World' kernel test"
-                         ],
-        "tag" : "basic",
-        "option_type": "common",
-        "value_type" : "array",
-        "options" : [
-          {
-            "name" : "latency",
-            "tag" : "basic",
-            "description" : "Run end-to-end latency test"
-          },
-          {
-            "name" : "throughput",
-            "tag" : "basic",
-            "description" : "Run end-to-end throughput test"
-          },
-          {
-            "name" : "cmd-chain-latency",
-            "tag" : "basic",
-            "description" : "Run command chain latency test"
-          },
-          {
-            "name" : "cmd-chain-throughput",
-            "tag" : "basic",
-            "description" : "Run end-to-end throughput test using command chaining"
-          },
-          {
-            "name" : "df-bw",
-            "tag" : "basic",
-            "description" : "Run dataflow bandwidth test"
-          },
-          {
-            "name" : "tct-one-col",
-            "tag" : "basic",
-            "description" : "Run TCT test with one column"
-          },
-          {
-            "name" : "tct-all-col",
-            "tag" : "basic",
-            "description" : "Run TCT test with all columns"
-          },
-          {
-            "name" : "gemm",
-            "tag" : "basic",
-            "description" : "Run GEMM test"
-          },
-          {
-            "name" : "aie-reconfig-overhead",
-            "tag" : "advanced",
-            "description" : "Run AIE reconfiguration overhead test"
-          },
-          {
-            "name" : "spatial-sharing-overhead",
-            "tag" : "advanced",
-            "description" : "Run spatial sharing overhead test"
-          },
-          {
-            "name" : "temporal-sharing-overhead",
-            "tag" : "advanced",
-            "description" : "Run temporal sharing overhead test"
-          },
-          {
-            "name" : "aie",
-            "tag" : "basic",
-            "description" : "Run AIE PL test"
-          },
-          {
-            "name" : "aux-connection",
-            "tag" : "basic",
-            "description" : "Check if auxiliary power is connected"
-          },
-          {
-            "name" : "dma",
-            "tag" : "basic",
-            "description" : "Run dma test"
-          },
-          {
-            "name" : "hostmem-bw",
-            "tag" : "basic",
-            "description" : "Run 'bandwidth kernel' when host memory is enabled"
-          },
-          {
-            "name" : "m2m",
-            "tag" : "basic",
-            "description" : "Run M2M test"
-          },
-          {
-            "name" : "mem-bw",
-            "tag" : "basic",
-            "description" : "Run 'bandwidth kernel' and check the throughput"
-          },
-          {
-            "name" : "p2p",
-            "tag" : "basic",
-            "description" : "Run P2P test"
-          },
-          {
-            "name" : "pcie-link",
-            "tag" : "basic",
-            "description" : "Check if PCIE link is active"
-          },
-          {
-            "name" : "tsc-version",
-            "tag" : "advanced",
-            "description" : "Check if SC firmware is up-to-date"
-          },
-          {
-            "name" : "verify",
-            "tag" : "advanced",
-            "description" : "Run 'Hello World' kernel test"
-          }
-        ]
-      },
-      {
-        "name" : "path",
-        "alias" : "p",
-        "description" : "Path to the directory containing validate xclbins",
-        "tag" : "basic",
-        "default_value": "",
-        "option_type": "hidden",
-        "value_type" : "string"
-      },
-      {
-        "name" : "param",
-        "description" : "Extended parameter for a given test. Format: <test-name>:<key>:<value>",
-        "tag" : "basic",
-        "option_type": "hidden",
-        "default_value": "",
-        "value_type" : "string"
-      },
-      {
-        "name" : "pmode",
-        "description" : "Specify which power mode to run the benchmarks in. Note: Some tests might be unavailable for some modes",
-        "tag" : "basic",
-        "option_type": "hidden",
-        "default_value": "",
-        "value_type" : "string"
-      }
-    ]
-  },
-  {
-    "name" : "examine",
-    "tag" : "basic",
-    "description": "This command will 'examine' the state of the system/device and will generate a report of interest in a text or JSON format.",
-    "options":
-    [
-      {
-        "name": "device",
-        "alias": "d",
-        "description": "The Bus:Device.Function (e.g., 0000:d8:00.0) device of interest",
-        "tag": "basic",
-        "default_value": "",
-        "option_type": "common",
-        "value_type": "string"
-      },
-      {
-        "name": "format",
-        "alias": "f",
-        "description": "Report output format",
-        "tag": "basic",
-        "default_value": "json",
-        "options_type": "common",
-        "value_type": "string"
-      },
-      {
-        "name": "output",
-        "alias": "o",
-        "description" : "Direct the output to the given file",
-        "tag": "basic",
-        "default_value": "",
-        "option_type": "common", 
-        "value_type" : "string"
-      },
-      {
-        "name": "help",
-        "alias": "h",
-        "description" : "Help to use this sub-command",
-        "tag": "basic",
-        "default_value": "",
-        "option_type": "common", 
-        "value_type" : "none"
-      },
-      {
-        "name": "report",
-        "alias": "r",
-        "description": "The type of report to be produced. Reports currently available are:",
-        "tag": "basic",
-        "option_type": "common",
-        "value_type": "array",
-        "options": [
-          {
-            "name": "host",
-            "tag": "basic",
-            "description": "Host information"
-          },
-          {
-            "name": "platform",
-            "tag": "basic",
-            "description": "Platforms flashed on the device"
-          },
-          {
-            "name": "aie-partitions",
-            "tag": "basic",
-            "description": "AIE partition information"
-          },
-          {
-            "name": "tememetry",
-            "tag": "basic",
-            "description": "Telemetry data for the device"
-          }
-        ]
-      },
-      {
-        "name": "element",
-        "alias": "e",
-        "description" : "Filters individual elements(s) from the report. Format: '/<key>/<key>/...'",
-        "tag": "basic",
-        "option_type": "hidden", 
-        "value_type" : "array"
-      } 
-    ]
-  },
-  {
-    "name" : "configure",
-    "tag" : "devl",
-    "description" : "Device and host configuration.",
-    "options" :
-    [
-      {
-        "name": "device",
-        "description": "The Bus:Device.Function (e.g., 0000:d8:00.0) device of interest",
-        "tag": "devl",
-        "value_type" : "string"
-      },
-      {
-        "name": "pmode",
-        "description": "Modes: default, powersaver, balanced, performance, turbo",
-        "tag": "basic",
-        "value_type": "string"
-      }
-    ]
-  }]
-} 
-)"
-  );
 }// end of namespace XBValidateUtils
diff --git a/src/runtime_src/core/tools/common/XBUtilities.h b/src/runtime_src/core/tools/common/XBUtilities.h
index aaa32a92786..c8e9b95da70 100644
--- a/src/runtime_src/core/tools/common/XBUtilities.h
+++ b/src/runtime_src/core/tools/common/XBUtilities.h
@@ -153,8 +153,6 @@ namespace XBUtilities {
       m_device->close_context(m_uuid, std::numeric_limits<unsigned int>::max());
     }
   };
-  std::string loadDefaultSmiConfig();
-
 };
 
 #endif
diff --git a/src/runtime_src/core/tools/xbflash2/CMakeLists.txt b/src/runtime_src/core/tools/xbflash2/CMakeLists.txt
index 6250f8862ab..dce47786d9d 100755
--- a/src/runtime_src/core/tools/xbflash2/CMakeLists.txt
+++ b/src/runtime_src/core/tools/xbflash2/CMakeLists.txt
@@ -18,7 +18,6 @@ file(GLOB XBFLASH_BASE_FILES
   "../common/OptionOptions.cpp"
   "../common/XBHelpMenusCore.cpp"
   "../common/JSONConfigurable.cpp"
-  "../common/SubCmdJsonObjects.cpp"
   "../../pcie/tools/xbflash.qspi/firmware_image.cpp"
   "../../pcie/tools/xbflash.qspi/pcidev.cpp"
   "../../pcie/tools/xbflash.qspi/xqspips.cpp"
diff --git a/src/runtime_src/core/tools/xbutil2/SubCmdValidate.cpp b/src/runtime_src/core/tools/xbutil2/SubCmdValidate.cpp
index 331c00c2874..41e4fb387e5 100644
--- a/src/runtime_src/core/tools/xbutil2/SubCmdValidate.cpp
+++ b/src/runtime_src/core/tools/xbutil2/SubCmdValidate.cpp
@@ -699,4 +699,17 @@ void SubCmdValidate::fill_option_values(const po::variables_map& vm, SubCmdValid
   options.m_pmode = vm.count("pmode") ? vm["pmode"].as<std::string>() : "";
   options.m_tests_to_run = vm.count("run") ? vm["run"].as<std::vector<std::string>>() : std::vector<std::string>({"all"});
   options.m_help = vm.count("help") ? vm["help"].as<bool>() : false;
-}
\ No newline at end of file
+}
+
+void
+SubCmdValidate::setOptionConfig(const boost::property_tree::ptree &config)
+{
+  m_jsonConfig = SubCmdJsonObjects::JsonConfig(config.get_child("subcommands"), getName());
+  try{
+    m_jsonConfig.addProgramOptions(m_commonOptions, "common", getName());
+    m_jsonConfig.addProgramOptions(m_hiddenOptions, "hidden", getName());
+  } 
+  catch (const std::exception& e) {
+    std::cerr << "Error: " << e.what() << std::endl;
+  }
+}
diff --git a/src/runtime_src/core/tools/xbutil2/SubCmdValidate.h b/src/runtime_src/core/tools/xbutil2/SubCmdValidate.h
index 0a7f4e3c864..d55a14e523f 100644
--- a/src/runtime_src/core/tools/xbutil2/SubCmdValidate.h
+++ b/src/runtime_src/core/tools/xbutil2/SubCmdValidate.h
@@ -23,6 +23,7 @@ struct SubCmdValidateOptions {
 class SubCmdValidate : public SubCmd {
  public:
   virtual void execute(const SubCmdOptions &_options) const;
+  virtual void setOptionConfig(const boost::property_tree::ptree &config) override;
 
  public:
   SubCmdValidate(bool _isHidden, bool _isDepricated, bool _isPreliminary, const boost::property_tree::ptree& configurations);